Trait ImportLoader 

pub trait ImportLoader: Debug {
    // Required methods
    fn resolve(
        &self,
        current: Option<&str>,
        path: &str,
    ) -> Result<String, Box<dyn Error + 'static>>;
    fn load(
        &self,
        path: &str,
    ) -> Result<Box<dyn Read>, Box<dyn Error + 'static>>;

    // Provided methods
    fn override(self, path: String, value: String) -> Override<Self>
       where Self: Sized { ... }
    fn block(self, path: String) -> Override<Self>
       where Self: Sized { ... }
    fn override_many(
        self,
        overrides: HashMap<String, Option<String>>,
    ) -> Override<Self>
       where Self: Sized { ... }
    fn filter<F>(self, filter: F) -> Filter<Self, F>
       where Self: Sized,
             F: Fn(&str) -> bool { ... }
    fn with_resolver<F, E>(self, resolver: F) -> WithResolver<Self, F>
       where Self: Sized,
             F: Fn(Option<&str>, &str) -> Result<String, E> { ... }
    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 { ... }
}

The loader trait for Ryan.

Required Methods

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.

Provided Methods

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.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl ImportLoader for DefaultImporter

impl ImportLoader for NoImport

impl<L: ImportLoader, F, E> ImportLoader for WithResolver<L, F>

where F: Fn(Option<&str>, &str) -> Result<String, E>, E: 'static + Error,

impl<L: ImportLoader, F, R, E> ImportLoader for WithLoader<L, F>

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

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

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

impl<L: ImportLoader> ImportLoader for Override<L>