Struct jlrs::data::managed::module::Module

#[repr(transparent)]
pub struct Module<'scope>(_, _);

Functionality in Julia can be accessed through its module system. You can get a handle to the three standard modules, Main, Base, and Core and access their submodules through them. If you include your own Julia code with Julia::include or AsyncJulia::include, its contents are made available relative to Main.

The most important methods offered are those that let you access submodules, functions, and other global values defined in the module.

Implementations

impl<'scope> Module<'scope>

pub fn name(self) -> Symbol<'scope>

Returns the name of this module.

pub fn parent(self) -> Module<'scope>

Returns the parent of this module.

pub unsafe fn extend<'target, T>(self, _: &T) -> Module<'target>where T: Target<'target>,

Extend the lifetime of this module. This is safe as long as the module is never redefined.

pub fn main<T: Target<'scope>>(_: &T) -> Self

Returns a handle to Julia’s Main-module. If you include your own Julia code with Julia::include or AsyncJulia::include its contents are made available relative to Main.

pub fn core<T: Target<'scope>>(_: &T) -> Self

Returns a handle to Julia’s Core-module.

pub fn base<T: Target<'scope>>(_: &T) -> Self

Returns a handle to Julia’s Base-module.

pub fn is_imported<N: ToSymbol>(self, sym: N) -> bool

Returns true if self has imported sym.

pub fn binding_type<'target, N, T>( self, target: T, var: N ) -> Option<ValueData<'target, 'static, T>>where N: ToSymbol, T: Target<'target>,

Returns the type of the binding in this module with the name var,

pub fn submodule<'target, N, T>( self, target: T, name: N ) -> JlrsResult<ModuleData<'target, T>>where N: ToSymbol, T: Target<'target>,

Returns the submodule named name relative to this module. You have to visit this level by level: you can’t access Main.A.B by calling this function with "A.B", but have to access A first and then B.

Returns an error if the submodule doesn’t exist.

pub fn package_root_module<'target, N: ToSymbol, T: Target<'target>>( target: &T, name: N ) -> Option<Module<'target>>

Returns the root module of the package named name.

All loaded packages can be accessed with this method. If the package doesn’t exist or hasn’t been loaded yet, None is returned.

pub unsafe fn set_global<'target, N, T>( self, target: T, name: N, value: Value<'_, 'static> ) -> T::Exception<'static, ()>where N: ToSymbol, T: Target<'target>,

Set a global value in this module. Note that if this global already exists, this can make the old value unreachable. If an excection is thrown, it’s caught, rooted and returned.

Safety: Mutating Julia data is generally unsafe because it can’t be guaranteed mutating this value is allowed.

pub unsafe fn set_global_unchecked<N>(self, name: N, value: Value<'_, 'static>)where N: ToSymbol,

Set a global value in this module. Note that if this global already exists, this can make the old value unreachable.

Safety: Mutating Julia data is generally unsafe because it can’t be guaranteed mutating this value is allowed.

pub fn set_const<'target, N, T>( self, target: T, name: N, value: Value<'_, 'static> ) -> T::Exception<'static, Value<'scope, 'static>>where N: ToSymbol, T: Target<'target>,

Set a constant in this module. If Julia throws an exception it’s caught and rooted in the current frame, if the exception can’t be rooted a JlrsError::AllocError is returned. If no exception is thrown an unrooted reference to the constant is returned.

pub unsafe fn set_const_unchecked<N>( self, name: N, value: Value<'_, 'static> ) -> Value<'scope, 'static>where N: ToSymbol,

Set a constant in this module. If the constant already exists the process aborts, otherwise an unrooted reference to the constant is returned.

Safety: This method must not throw an error if called from a ccalled function.

pub fn global<'target, N, T>( self, target: T, name: N ) -> JlrsResult<ValueData<'target, 'static, T>>where N: ToSymbol, T: Target<'target>,

Returns the global named name in this module. Returns an error if the global doesn’t exist.

pub fn function<'target, N, T>( self, target: T, name: N ) -> JlrsResult<FunctionData<'target, 'static, T>>where N: ToSymbol, T: Target<'target>,

Returns the function named name in this module. Returns an error if the function doesn’t exist or if it’s not a subtype of Function.

pub unsafe fn require<'target, T, N>( self, target: T, module: N ) -> ValueResult<'target, 'static, T>where T: Target<'target>, N: ToSymbol,

Load a module by calling Base.require and return this module if it has been loaded successfully. This method can be used to load parts of the standard library like LinearAlgebra. This requires one slot on the GC stack. Note that the loaded module is not made available in the module used to call this method, you can use Module::set_global to do so.

Note that when you want to call using Submodule in the Main module, you can do so by evaluating the using-statement with Value::eval_string.

Safety: This method can execute arbitrary Julia code depending on the module that is loaded.

Trait Implementations

impl<'scope> AccessPlotsModule for Module<'scope>

fn plots<'global, T: Target<'global>>(target: &T) -> Module<'global>

Returns the Plots module.

impl<'scope, 'data> AsTyped<'scope, 'data> for Module<'scope>

fn as_typed(self) -> JlrsResult<TypedValue<'scope, 'data, Self>>

impl<'scope> CCallArg for Module<'scope>

type CCallArgType = Value<'scope, 'static>

type FunctionArgType = Module<'scope>

impl<'scope> Clone for Module<'scope>

fn clone(&self) -> Module<'scope>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConstructType for Module<'_>

fn construct_type<'target, 'current, 'borrow, T>( target: ExtendedTarget<'target, '_, '_, T> ) -> ValueData<'target, 'static, T>where T: Target<'target>,

Constructs the type object associated with this type.

fn base_type<'target, Tgt>(_target: &Tgt) -> Option<Value<'target, 'static>>where Tgt: Target<'target>,

Returns the base type object associated with this type.

fn is_compatible<T>(frame: &mut GcFrame<'_>) -> boolwhere T: ValidField,

Returns true if T is a valid field layout for instances of the constructed type.

impl Debug for Module<'_>

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

Formats the value using the given formatter.

impl<'scope> PartialEq<Module<'scope>> for Module<'scope>

fn eq(&self, other: &Module<'scope>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'target> Typecheck for Module<'target>

fn typecheck(t: DataType<'_>) -> bool

Returns whether the property implied by Self holds true.

impl ValidLayout for Module<'_>

fn valid_layout(ty: Value<'_, '_>) -> bool

Check if the layout of the implementor is compatible with the layout of ty. This argument is a Value to account for the fact that a field type can be a Union, UnionAll or Union{}.

const IS_REF: bool = true

Must be true if the Rust type is a managed type.

impl<'scope> Copy for Module<'scope>

impl<'scope> StructuralPartialEq for Module<'scope>