Struct Filter

pub struct Filter<L, F> { /* private fields */ }

The resulting loader for the ImportLoader::filter method.

Trait Implementations

impl<L: Debug, F> Debug for Filter<L, F>

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

Formats the value using the given formatter.

impl<L: ImportLoader, F> ImportLoader for Filter<L, F>

where F: Fn(&str) -> bool,

fn resolve( &self, current: Option<&str>, path: &str, ) -> Result<String, Box<dyn Error + 'static>>

Returns the absolute import path for a module, given a base and an optional path. The base might be set to None in some cases (e.g., when loading Ryan from a string, not a file). Each loader implementation can choose how to treat this value however it’s expedient.

fn load(&self, path: &str) -> Result<Box<dyn Read>, Box<dyn Error + 'static>>

Resolves an absolute path into a reader, where a Ryan module can be read from.

fn override(self, path: String, value: String) -> Override<Self>

where Self: Sized,

Overrides a single path to be represented by a different model than would be represented by this loader.

fn block(self, path: String) -> Override<Self>

where Self: Sized,

Blocks a path from being resolved as a module.

fn override_many( self, overrides: HashMap<String, Option<String>>, ) -> Override<Self>

where Self: Sized,

Overrides the value imported by multiple paths. Pass None as the value associated to a key in the hashmap to deny access to a given path.

fn filter<F>(self, filter: F) -> Filter<Self, F>

where Self: Sized, F: Fn(&str) -> bool,

Determines whether a path should be blocked or loaded based on a supplied closure.

fn with_resolver<F, E>(self, resolver: F) -> WithResolver<Self, F>

where Self: Sized, F: Fn(Option<&str>, &str) -> Result<String, E>,

Change the resolve method of the underlying loader.

fn with_loader<F, R, E>(self, loader: F) -> WithLoader<Self, F>

where Self: Sized, F: Fn(&str) -> Result<R, E>, R: 'static + Read, E: 'static + Error,

Change the load method of the underlying loader.