Struct rhai::module_resolvers::ModuleResolversCollection

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

Module resolution service that holds a collection of module resolvers, to be searched in sequential order.

Example

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

let mut collection = ModuleResolversCollection::new();

let resolver = StaticModuleResolver::new();
collection.push(resolver);

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

Implementations

impl ModuleResolversCollection

pub const fn new() -> Self

Create a new ModuleResolversCollection.

Example

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

let mut collection = ModuleResolversCollection::new();

let resolver = StaticModuleResolver::new();
collection.push(resolver);

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

pub fn push(&mut self, resolver: impl ModuleResolver + 'static) -> &mut Self

Append a module resolver to the end.

pub fn insert( &mut self, index: usize, resolver: impl ModuleResolver + 'static ) -> &mut Self

Insert a module resolver to an offset index.

Panics

Panics if the index is out of bounds.

pub fn pop(&mut self) -> Option<Box<dyn ModuleResolver>>

Remove the last module resolver from the end, if any.

pub fn remove(&mut self, index: usize) -> Box<dyn ModuleResolver>

Remove a module resolver at an offset index.

Panics

Panics if the index is out of bounds.

pub fn iter(&self) -> impl Iterator<Item = &dyn ModuleResolver>

Get an iterator of all the module resolvers.

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

Remove all module resolvers.

pub fn is_empty(&self) -> bool

Returns true if this ModuleResolversCollection contains no module resolvers.

pub fn len(&self) -> usize

Get the number of module resolvers in this ModuleResolversCollection.

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

Add another ModuleResolversCollection to the end of this collection. The other ModuleResolversCollection is consumed.

Trait Implementations

impl<M: ModuleResolver + 'static> AddAssign<M> for ModuleResolversCollection

fn add_assign(&mut self, rhs: M)

Performs the += operation.

impl Default for ModuleResolversCollection

fn default() -> ModuleResolversCollection

Returns the “default value” for a type.

impl Extend<Box<dyn ModuleResolver, Global>> for ModuleResolversCollection

fn extend<T: IntoIterator<Item = Box<dyn ModuleResolver>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> IntoIterator for &'a ModuleResolversCollection

type Item = &'a Box<dyn ModuleResolver, Global>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Box<dyn ModuleResolver, Global>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for ModuleResolversCollection

type Item = Box<dyn ModuleResolver, Global>

The type of the elements being iterated over.

type IntoIter = IntoIter<[Box<dyn ModuleResolver, Global>; 3]>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl ModuleResolver for ModuleResolversCollection

fn resolve( &self, engine: &Engine, source_path: 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, scope: &mut Scope<'_>, path: &str, pos: Position ) -> Result<Shared<Module>, Box<EvalAltResult>>

Resolve a module based on a path string, given a GlobalRuntimeState and the current Scope.

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.