Struct gluon::import::Import

pub struct Import<I = DefaultImporter> {
    pub paths: RwLock<Vec<PathBuf>>,
    pub importer: I,
    pub compiler: Mutex<CompilerDatabase>,
}

Macro which rewrites occurances of import! "filename" to a load of that file if it is not already loaded and then a global access to the loaded module

Fields

paths: RwLock<Vec<PathBuf>>

importer: I

compiler: Mutex<CompilerDatabase>

Implementations

impl<I> Import<I>

pub fn new(importer: I) -> Import<I>

Creates a new import macro

pub fn add_path<P: Into<PathBuf>>(&self, path: P)

Adds a path to the list of paths which the importer uses to find files

pub fn set_paths(&self, paths: Vec<PathBuf>)

pub fn modules(&self, compiler: &mut ModuleCompiler) -> Vec<Cow<'static, str>>

pub fn database_mut(self: Arc<Self>, thread: RootedThread) -> DatabaseMut where
    I: Importer, 

pub fn snapshot(&self, thread: RootedThread) -> DatabaseSnapshot

pub fn fork(
    &self,
    forker: ForkState<CompilerDatabase>,
    thread: RootedThread
) -> DatabaseFork

Trait Implementations

impl<I> Macro for Import<I> where
    I: Importer, 

fn get_capability_impl(
    &self,
    thread: &Thread,
    arc_self: &Arc<dyn Macro>,
    id: TypeId
) -> Option<Box<dyn Any>>

fn expand<'r, 'a: 'r, 'b: 'r, 'ast: 'r>(
    &self,
    macros: &'b mut MacroExpander<'a>,
    _arena: &'b mut OwnedArena<'ast, Symbol>,
    args: &'b mut [SpannedExpr<'ast, Symbol>]
) -> MacroFuture<'r, 'ast>

fn get_capability<T>(
    &self,
    thread: &Thread,
    arc_self: &Arc<dyn Macro + 'static>
) -> Option<T> where
    T: Any, 

impl<I> Trace for Import<I>

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

fn trace(&self, _gc: &mut Gc)