pub struct Module { /* private fields */ }
Expand description
A module which may contain variables, sub-modules, external Rust functions, and/or script-defined functions.
Implementations§
source§impl Module
impl Module
sourcepub const fn with_capacity(_capacity: usize) -> Self
👎Deprecated since 1.12.0: use new
instead
pub const fn with_capacity(_capacity: usize) -> Self
new
insteadsourcepub fn get_custom_type(&self, type_name: &str) -> Option<&str>
👎Deprecated since 1.16.0: use get_custom_type_display_by_name
instead
pub fn get_custom_type(&self, type_name: &str) -> Option<&str>
get_custom_type_display_by_name
insteadGet the display name of a registered custom type.
§Deprecated
This method is deprecated.
Use get_custom_type_display_by_name
instead.
This method will be removed in the next major version.
sourcepub fn set_fn(
&mut self,
name: impl Into<Identifier>,
namespace: FnNamespace,
_access: FnAccess,
arg_names: Option<&[&str]>,
arg_types: impl AsRef<[TypeId]>,
func: RhaiFunc
) -> u64
👎Deprecated since 1.17.0: use the FuncRegistration
API instead
pub fn set_fn( &mut self, name: impl Into<Identifier>, namespace: FnNamespace, _access: FnAccess, arg_names: Option<&[&str]>, arg_types: impl AsRef<[TypeId]>, func: RhaiFunc ) -> u64
FuncRegistration
API insteadSet a native Rust function into the Module
, returning a u64
hash key.
If there is an existing Rust function of the same hash, it is replaced.
§Deprecated
This method is deprecated.
Use the FuncRegistration
API instead.
This method will be removed in the next major version.
sourcepub fn set_fn_with_comments<C: AsRef<str>>(
&mut self,
name: impl Into<Identifier>,
namespace: FnNamespace,
_access: FnAccess,
arg_names: Option<&[&str]>,
arg_types: impl AsRef<[TypeId]>,
comments: impl IntoIterator<Item = C>,
func: RhaiFunc
) -> u64
👎Deprecated since 1.17.0: use the FuncRegistration
API instead
pub fn set_fn_with_comments<C: AsRef<str>>( &mut self, name: impl Into<Identifier>, namespace: FnNamespace, _access: FnAccess, arg_names: Option<&[&str]>, arg_types: impl AsRef<[TypeId]>, comments: impl IntoIterator<Item = C>, func: RhaiFunc ) -> u64
FuncRegistration
API instead(metadata) Set a native Rust function into the Module
, returning a u64
hash key.
Exported under the metadata
feature only.
If there is an existing Rust function of the same hash, it is replaced.
§Deprecated
This method is deprecated.
Use the FuncRegistration
API instead.
This method will be removed in the next major version.
sourcepub fn update_fn_metadata<S: Into<Identifier>>(
&mut self,
hash_fn: u64,
arg_names: impl IntoIterator<Item = S>
) -> &mut Self
👎Deprecated since 1.17.0: use update_fn_metadata_with_comments
instead
pub fn update_fn_metadata<S: Into<Identifier>>( &mut self, hash_fn: u64, arg_names: impl IntoIterator<Item = S> ) -> &mut Self
update_fn_metadata_with_comments
instead(metadata) Update the metadata (parameter names/types and return type) of a registered function.
Exported under the metadata
feature only.
The u64
hash is returned by the set_native_fn
call.
§Deprecated
This method is deprecated.
Use update_fn_metadata_with_comments
instead.
This method will be removed in the next major version.
sourcepub fn gen_fn_signatures(&self) -> impl Iterator<Item = String> + '_
👎Deprecated since 1.17.0: use gen_fn_signatures_with_mapper
instead
pub fn gen_fn_signatures(&self) -> impl Iterator<Item = String> + '_
gen_fn_signatures_with_mapper
instead(metadata) Generate signatures for all the non-private functions in the Module
.
Exported under the metadata
feature only.
§Deprecated
This method is deprecated.
Use gen_fn_signatures_with_mapper
instead.
This method will be removed in the next major version.
source§impl Module
impl Module
sourcepub fn set_id(&mut self, id: impl Into<ImmutableString>) -> &mut Self
pub fn set_id(&mut self, id: impl Into<ImmutableString>) -> &mut Self
sourcepub fn set_doc(&mut self, doc: impl Into<SmartString<LazyCompact>>) -> &mut Self
pub fn set_doc(&mut self, doc: impl Into<SmartString<LazyCompact>>) -> &mut Self
Set the documentation of the Module
.
Exported under the metadata
feature only.
If the string is empty, it is equivalent to clearing the documentation.
§Example
let mut module = Module::new();
module.set_doc("//! This is my special module.");
assert_eq!(module.doc(), "//! This is my special module.");
sourcepub fn set_custom_type<T>(&mut self, name: &str) -> &mut Self
pub fn set_custom_type<T>(&mut self, name: &str) -> &mut Self
Map a custom type to a friendly display name.
§Example
#[derive(Clone)]
struct TestStruct;
let name = std::any::type_name::<TestStruct>();
let mut module = Module::new();
module.set_custom_type::<TestStruct>("MyType");
assert_eq!(module.get_custom_type_display_by_name(name), Some("MyType"));
sourcepub fn set_custom_type_with_comments<T>(
&mut self,
name: &str,
comments: &[&str]
) -> &mut Self
pub fn set_custom_type_with_comments<T>( &mut self, name: &str, comments: &[&str] ) -> &mut Self
Map a custom type to a friendly display name.
Exported under the metadata
feature only.
§Comments
Block doc-comments should be kept in a separate string slice.
Line doc-comments should be merged, with line-breaks, into a single string slice without a final termination line-break.
Leading white-spaces should be stripped, and each string slice always starts with the corresponding
doc-comment leader: ///
or /**
.
Each line in non-block doc-comments should start with ///
.
sourcepub fn set_custom_type_raw(
&mut self,
type_name: impl Into<Identifier>,
display_name: impl Into<Identifier>
) -> &mut Self
pub fn set_custom_type_raw( &mut self, type_name: impl Into<Identifier>, display_name: impl Into<Identifier> ) -> &mut Self
Map a custom type to a friendly display name.
#[derive(Clone)]
struct TestStruct;
let name = std::any::type_name::<TestStruct>();
let mut module = Module::new();
module.set_custom_type_raw(name, "MyType");
assert_eq!(module.get_custom_type_display_by_name(name), Some("MyType"));
sourcepub fn set_custom_type_with_comments_raw<C: Into<SmartString<LazyCompact>>>(
&mut self,
type_name: impl Into<Identifier>,
display_name: impl Into<Identifier>,
comments: impl IntoIterator<Item = C>
) -> &mut Self
pub fn set_custom_type_with_comments_raw<C: Into<SmartString<LazyCompact>>>( &mut self, type_name: impl Into<Identifier>, display_name: impl Into<Identifier>, comments: impl IntoIterator<Item = C> ) -> &mut Self
Map a custom type to a friendly display name.
Exported under the metadata
feature only.
§Comments
Block doc-comments should be kept in a separate string slice.
Line doc-comments should be merged, with line-breaks, into a single string slice without a final termination line-break.
Leading white-spaces should be stripped, and each string slice always starts with the corresponding
doc-comment leader: ///
or /**
.
Each line in non-block doc-comments should start with ///
.
sourcepub fn get_custom_type_display_by_name(&self, type_name: &str) -> Option<&str>
pub fn get_custom_type_display_by_name(&self, type_name: &str) -> Option<&str>
Get the display name of a registered custom type.
§Example
#[derive(Clone)]
struct TestStruct;
let name = std::any::type_name::<TestStruct>();
let mut module = Module::new();
module.set_custom_type::<TestStruct>("MyType");
assert_eq!(module.get_custom_type_display_by_name(name), Some("MyType"));
sourcepub fn get_custom_type_display<T>(&self) -> Option<&str>
pub fn get_custom_type_display<T>(&self) -> Option<&str>
Get the display name of a registered custom type.
§Example
#[derive(Clone)]
struct TestStruct;
let name = std::any::type_name::<TestStruct>();
let mut module = Module::new();
module.set_custom_type::<TestStruct>("MyType");
assert_eq!(module.get_custom_type_display::<TestStruct>(), Some("MyType"));
sourcepub fn get_custom_type_raw<T>(&self) -> Option<&CustomTypeInfo>
pub fn get_custom_type_raw<T>(&self) -> Option<&CustomTypeInfo>
(internals) Get a registered custom type .
Exported under the internals
feature only.
sourcepub fn get_custom_type_by_name_raw(
&self,
type_name: &str
) -> Option<&CustomTypeInfo>
pub fn get_custom_type_by_name_raw( &self, type_name: &str ) -> Option<&CustomTypeInfo>
(internals) Get a registered custom type by its type name.
Exported under the internals
feature only.
sourcepub const fn is_indexed(&self) -> bool
pub const fn is_indexed(&self) -> bool
Is the Module
indexed?
A module must be indexed before it can be used in an import
statement.
§Example
let mut module = Module::new();
assert!(module.is_indexed());
module.set_native_fn("foo", |x: &mut i64, y: i64| { *x = y; Ok(()) });
assert!(!module.is_indexed());
module.build_index();
assert!(module.is_indexed());
sourcepub const fn is_internal(&self) -> bool
pub const fn is_internal(&self) -> bool
Is the Module
an internal Rhai system module?
sourcepub const fn is_standard_lib(&self) -> bool
pub const fn is_standard_lib(&self) -> bool
Is the Module
a Rhai standard library module?
sourcepub fn gen_fn_signatures_with_mapper<'a>(
&'a self,
type_mapper: impl Fn(&'a str) -> Cow<'a, str> + 'a
) -> impl Iterator<Item = String> + 'a
pub fn gen_fn_signatures_with_mapper<'a>( &'a self, type_mapper: impl Fn(&'a str) -> Cow<'a, str> + 'a ) -> impl Iterator<Item = String> + 'a
(metadata) Generate signatures for all the non-private functions in the Module
.
Exported under the metadata
feature only.
sourcepub fn contains_var(&self, name: &str) -> bool
pub fn contains_var(&self, name: &str) -> bool
sourcepub fn set_var(
&mut self,
name: impl Into<Identifier>,
value: impl Variant + Clone
) -> &mut Self
pub fn set_var( &mut self, name: impl Into<Identifier>, value: impl Variant + Clone ) -> &mut Self
sourcepub fn set_script_fn(&mut self, fn_def: impl Into<Shared<ScriptFuncDef>>) -> u64
pub fn set_script_fn(&mut self, fn_def: impl Into<Shared<ScriptFuncDef>>) -> u64
Set a script-defined function into the Module
.
If there is an existing function of the same name and number of arguments, it is replaced.
sourcepub fn get_script_fn(
&self,
name: impl AsRef<str>,
num_params: usize
) -> Option<&Shared<ScriptFuncDef>>
pub fn get_script_fn( &self, name: impl AsRef<str>, num_params: usize ) -> Option<&Shared<ScriptFuncDef>>
Get a shared reference to the script-defined function in the Module
based on name
and number of parameters.
sourcepub fn contains_sub_module(&self, name: &str) -> bool
pub fn contains_sub_module(&self, name: &str) -> bool
sourcepub fn get_sub_module(&self, name: &str) -> Option<&Self>
pub fn get_sub_module(&self, name: &str) -> Option<&Self>
sourcepub fn set_sub_module(
&mut self,
name: impl Into<Identifier>,
sub_module: impl Into<Shared<Module>>
) -> &mut Self
pub fn set_sub_module( &mut self, name: impl Into<Identifier>, sub_module: impl Into<Shared<Module>> ) -> &mut Self
sourcepub fn contains_fn(&self, hash_fn: u64) -> bool
pub fn contains_fn(&self, hash_fn: u64) -> bool
Does the particular Rust function exist in the Module
?
The u64
hash is returned by the set_native_fn
call.
§Example
let mut module = Module::new();
let hash = module.set_native_fn("calc", |x: i64| Ok(42 + x));
assert!(module.contains_fn(hash));
sourcepub fn update_fn_metadata_with_comments<A: Into<Identifier>, C: Into<SmartString<LazyCompact>>>(
&mut self,
hash_fn: u64,
arg_names: impl IntoIterator<Item = A>,
comments: impl IntoIterator<Item = C>
) -> &mut Self
👎Deprecated since 1.17.0: use the FuncRegistration
API instead
pub fn update_fn_metadata_with_comments<A: Into<Identifier>, C: Into<SmartString<LazyCompact>>>( &mut self, hash_fn: u64, arg_names: impl IntoIterator<Item = A>, comments: impl IntoIterator<Item = C> ) -> &mut Self
FuncRegistration
API instead(metadata) Update the metadata (parameter names/types, return type and doc-comments) of a registered function.
Exported under the metadata
feature only.
§Deprecated
This method is deprecated.
Use the FuncRegistration
API instead.
This method will be removed in the next major version.
sourcepub fn update_fn_namespace(
&mut self,
hash_fn: u64,
namespace: FnNamespace
) -> &mut Self
👎Deprecated since 1.17.0: use the FuncRegistration
API instead
pub fn update_fn_namespace( &mut self, hash_fn: u64, namespace: FnNamespace ) -> &mut Self
FuncRegistration
API insteadUpdate the namespace of a registered function.
§Deprecated
This method is deprecated.
Use the FuncRegistration
API instead.
This method will be removed in the next major version.
sourcepub fn set_fn_raw_with_options(
&mut self,
options: FuncRegistration,
arg_types: impl AsRef<[TypeId]>,
func: RhaiFunc
) -> &FuncMetadata
pub fn set_fn_raw_with_options( &mut self, options: FuncRegistration, arg_types: impl AsRef<[TypeId]>, func: RhaiFunc ) -> &FuncMetadata
Set a native Rust function into the Module
based on a FuncRegistration
.
§WARNING - Low Level API
This function is very low level. It takes a list of TypeId
’s
indicating the actual types of the parameters.
sourcepub fn set_native_fn<A: 'static, const N: usize, const X: bool, R, FUNC>(
&mut self,
name: impl Into<Identifier>,
func: FUNC
) -> u64
pub fn set_native_fn<A: 'static, const N: usize, const X: bool, R, FUNC>( &mut self, name: impl Into<Identifier>, func: FUNC ) -> u64
Set a native Rust function into the Module
, returning a u64
hash key.
If there is a similar existing Rust function, it is replaced.
§Use FuncRegistration
API
It is recommended that the FuncRegistration
API be used instead.
Essentially, this method is a shortcut for:
FuncRegistration::new(name)
.in_internal_namespace()
.with_purity(true)
.with_volatility(false)
.set_into_module(module, func)
.hash
§Assumptions
-
Accessibility: The function namespace is
FnNamespace::Internal
. -
Purity: The function is assumed to be pure unless it is a property setter or an index setter.
-
Volatility: The function is assumed to be non-volatile – i.e. it guarantees the same result for the same input(s).
-
Metadata: No metadata for the function is registered.
To change these assumptions, use the FuncRegistration
API instead.
§Example
let mut module = Module::new();
let hash = module.set_native_fn("calc", |x: i64| Ok(42 + x));
assert!(module.contains_fn(hash));
sourcepub fn set_getter_fn<A, const X: bool, R, FUNC>(
&mut self,
name: impl AsRef<str>,
func: FUNC
) -> u64where
A: Variant + Clone,
R: Variant + Clone,
FUNC: RhaiNativeFunc<(Mut<A>,), 1, X, R, true> + SendSync + 'static,
pub fn set_getter_fn<A, const X: bool, R, FUNC>(
&mut self,
name: impl AsRef<str>,
func: FUNC
) -> u64where
A: Variant + Clone,
R: Variant + Clone,
FUNC: RhaiNativeFunc<(Mut<A>,), 1, X, R, true> + SendSync + 'static,
Set a Rust getter function taking one mutable parameter, returning a u64
hash key.
This function is automatically exposed to the global namespace.
If there is a similar existing Rust getter function, it is replaced.
§Assumptions
-
Accessibility: The function namespace is
FnNamespace::Global
. -
Purity: The function is assumed to be pure (so it can be called on constants).
-
Volatility: The function is assumed to be non-volatile – i.e. it guarantees the same result for the same input(s).
-
Metadata: No metadata for the function is registered.
To change these assumptions, use the FuncRegistration
API instead.
§Example
let mut module = Module::new();
let hash = module.set_getter_fn("value", |x: &mut i64| Ok(*x));
assert!(module.contains_fn(hash));
sourcepub fn set_setter_fn<A, const X: bool, R, FUNC>(
&mut self,
name: impl AsRef<str>,
func: FUNC
) -> u64
pub fn set_setter_fn<A, const X: bool, R, FUNC>( &mut self, name: impl AsRef<str>, func: FUNC ) -> u64
Set a Rust setter function taking two parameters (the first one mutable) into the Module
,
returning a u64
hash key.
This function is automatically exposed to the global namespace.
If there is a similar existing setter Rust function, it is replaced.
§Assumptions
-
Accessibility: The function namespace is
FnNamespace::Global
. -
Purity: The function is assumed to be non-pure (so it cannot be called on constants).
-
Volatility: The function is assumed to be non-volatile – i.e. it guarantees the same result for the same input(s).
-
Metadata: No metadata for the function is registered.
To change these assumptions, use the FuncRegistration
API instead.
§Example
use rhai::{Module, ImmutableString};
let mut module = Module::new();
let hash = module.set_setter_fn("value", |x: &mut i64, y: ImmutableString| {
*x = y.len() as i64; Ok(())
});
assert!(module.contains_fn(hash));
sourcepub fn set_getter_setter_fn<A: Variant + Clone, const X1: bool, const X2: bool, R: Variant + Clone>(
&mut self,
name: impl AsRef<str>,
getter: impl RhaiNativeFunc<(Mut<A>,), 1, X1, R, true> + SendSync + 'static,
setter: impl RhaiNativeFunc<(Mut<A>, R), 2, X2, (), true> + SendSync + 'static
) -> (u64, u64)
pub fn set_getter_setter_fn<A: Variant + Clone, const X1: bool, const X2: bool, R: Variant + Clone>( &mut self, name: impl AsRef<str>, getter: impl RhaiNativeFunc<(Mut<A>,), 1, X1, R, true> + SendSync + 'static, setter: impl RhaiNativeFunc<(Mut<A>, R), 2, X2, (), true> + SendSync + 'static ) -> (u64, u64)
Set a pair of Rust getter and setter functions into the Module
, returning both u64
hash keys.
This is a short-hand for set_getter_fn
and set_setter_fn
.
These function are automatically exposed to the global namespace.
If there are similar existing Rust functions, they are replaced.
To change these assumptions, use the FuncRegistration
API instead.
§Example
use rhai::{Module, ImmutableString};
let mut module = Module::new();
let (hash_get, hash_set) =
module.set_getter_setter_fn("value",
|x: &mut i64| Ok(x.to_string().into()),
|x: &mut i64, y: ImmutableString| { *x = y.len() as i64; Ok(()) }
);
assert!(module.contains_fn(hash_get));
assert!(module.contains_fn(hash_set));
sourcepub fn set_indexer_get_fn<A, B, const X: bool, R, FUNC>(
&mut self,
func: FUNC
) -> u64
pub fn set_indexer_get_fn<A, B, const X: bool, R, FUNC>( &mut self, func: FUNC ) -> u64
Set a Rust index getter taking two parameters (the first one mutable) into the Module
,
returning a u64
hash key.
This function is automatically exposed to the global namespace.
If there is a similar existing setter Rust function, it is replaced.
§Assumptions
-
Accessibility: The function namespace is
FnNamespace::Global
. -
Purity: The function is assumed to be pure (so it can be called on constants).
-
Volatility: The function is assumed to be non-volatile – i.e. it guarantees the same result for the same input(s).
-
Metadata: No metadata for the function is registered.
To change these assumptions, use the FuncRegistration
API instead.
§Panics
Panics if the type is Array
, Map
, String
,
ImmutableString
, &str
or INT
.
Indexers for arrays, object maps, strings and integers cannot be registered.
§Example
use rhai::{Module, ImmutableString};
#[derive(Clone)]
struct TestStruct(i64);
let mut module = Module::new();
let hash = module.set_indexer_get_fn(
|x: &mut TestStruct, y: ImmutableString| Ok(x.0 + y.len() as i64)
);
assert!(module.contains_fn(hash));
sourcepub fn set_indexer_set_fn<A, B, const X: bool, R, FUNC>(
&mut self,
func: FUNC
) -> u64
pub fn set_indexer_set_fn<A, B, const X: bool, R, FUNC>( &mut self, func: FUNC ) -> u64
Set a Rust index setter taking three parameters (the first one mutable) into the Module
,
returning a u64
hash key.
This function is automatically exposed to the global namespace.
If there is a similar existing Rust function, it is replaced.
§Assumptions
-
Accessibility: The function namespace is
FnNamespace::Global
. -
Purity: The function is assumed to be non-pure (so it cannot be called on constants).
-
Volatility: The function is assumed to be non-volatile – i.e. it guarantees the same result for the same input(s).
§Panics
Panics if the type is Array
, Map
, String
,
ImmutableString
, &str
or INT
.
Indexers for arrays, object maps, strings and integers cannot be registered.
§Example
use rhai::{Module, ImmutableString};
#[derive(Clone)]
struct TestStruct(i64);
let mut module = Module::new();
let hash = module.set_indexer_set_fn(|x: &mut TestStruct, y: ImmutableString, value: i64| {
*x = TestStruct(y.len() as i64 + value);
Ok(())
});
assert!(module.contains_fn(hash));
sourcepub fn set_indexer_get_set_fn<A: Variant + Clone, B: Variant + Clone, const X1: bool, const X2: bool, R: Variant + Clone>(
&mut self,
get_fn: impl RhaiNativeFunc<(Mut<A>, B), 2, X1, R, true> + SendSync + 'static,
set_fn: impl RhaiNativeFunc<(Mut<A>, B, R), 3, X2, (), true> + SendSync + 'static
) -> (u64, u64)
pub fn set_indexer_get_set_fn<A: Variant + Clone, B: Variant + Clone, const X1: bool, const X2: bool, R: Variant + Clone>( &mut self, get_fn: impl RhaiNativeFunc<(Mut<A>, B), 2, X1, R, true> + SendSync + 'static, set_fn: impl RhaiNativeFunc<(Mut<A>, B, R), 3, X2, (), true> + SendSync + 'static ) -> (u64, u64)
Set a pair of Rust index getter and setter functions into the Module
, returning both u64
hash keys.
This is a short-hand for set_indexer_get_fn
and
set_indexer_set_fn
.
These functions are automatically exposed to the global namespace.
If there are similar existing Rust functions, they are replaced.
§Panics
Panics if the type is Array
, Map
, String
,
ImmutableString
, &str
or INT
.
Indexers for arrays, object maps, strings and integers cannot be registered.
§Example
use rhai::{Module, ImmutableString};
#[derive(Clone)]
struct TestStruct(i64);
let mut module = Module::new();
let (hash_get, hash_set) = module.set_indexer_get_set_fn(
|x: &mut TestStruct, y: ImmutableString| Ok(x.0 + y.len() as i64),
|x: &mut TestStruct, y: ImmutableString, value: i64| { *x = TestStruct(y.len() as i64 + value); Ok(()) }
);
assert!(module.contains_fn(hash_get));
assert!(module.contains_fn(hash_set));
sourcepub fn contains_qualified_fn(&self, hash_fn: u64) -> bool
pub fn contains_qualified_fn(&self, hash_fn: u64) -> bool
Does the particular namespace-qualified function exist in the Module
?
The u64
hash is calculated by build_index
.
sourcepub fn combine_flatten(&mut self, other: Self) -> &mut Self
pub fn combine_flatten(&mut self, other: Self) -> &mut Self
sourcepub fn count(&self) -> (usize, usize, usize)
pub fn count(&self) -> (usize, usize, usize)
Get the number of variables, functions and type iterators in the Module
.
sourcepub fn iter_sub_modules(&self) -> impl Iterator<Item = (&str, &Shared<Module>)>
pub fn iter_sub_modules(&self) -> impl Iterator<Item = (&str, &Shared<Module>)>
Get an iterator to the sub-modules in the Module
.
sourcepub fn iter_var(&self) -> impl Iterator<Item = (&str, &Dynamic)>
pub fn iter_var(&self) -> impl Iterator<Item = (&str, &Dynamic)>
Get an iterator to the variables in the Module
.
sourcepub fn iter_script_fn_info(
&self
) -> impl Iterator<Item = (FnNamespace, FnAccess, &str, usize, &Shared<ScriptFuncDef>)>
pub fn iter_script_fn_info( &self ) -> impl Iterator<Item = (FnNamespace, FnAccess, &str, usize, &Shared<ScriptFuncDef>)>
(internals) Get an iterator over all script-defined functions in the Module
.
Exported under the internals
feature only.
Function metadata includes:
- Namespace (
FnNamespace::Global
orFnNamespace::Internal
). - Access mode (
FnAccess::Public
orFnAccess::Private
). - Function name (as string slice).
- Number of parameters.
- (internals) Shared reference to function definition
ScriptFuncDef
.
sourcepub fn eval_ast_as_new(
scope: Scope<'_>,
ast: &AST,
engine: &Engine
) -> Result<Self, Box<EvalAltResult>>
pub fn eval_ast_as_new( scope: Scope<'_>, ast: &AST, engine: &Engine ) -> Result<Self, Box<EvalAltResult>>
Create a new Module
by evaluating an AST
.
The entire AST
is encapsulated into each function, allowing functions to
cross-call each other.
§Example
use rhai::{Engine, Module, Scope};
let engine = Engine::new();
let ast = engine.compile("let answer = 42; export answer;")?;
let module = Module::eval_ast_as_new(Scope::new(), &ast, &engine)?;
assert!(module.contains_var("answer"));
assert_eq!(module.get_var_value::<i64>("answer").expect("answer should exist"), 42);
sourcepub fn eval_ast_as_new_raw(
engine: &Engine,
scope: &mut Scope<'_>,
global: &mut GlobalRuntimeState,
ast: &AST
) -> Result<Self, Box<EvalAltResult>>
pub fn eval_ast_as_new_raw( engine: &Engine, scope: &mut Scope<'_>, global: &mut GlobalRuntimeState, ast: &AST ) -> Result<Self, Box<EvalAltResult>>
Create a new Module
by evaluating an AST
.
The entire AST
is encapsulated into each function, allowing functions to
cross-call each other.
§WARNING - Low Level API
This function is very low level.
In particular, the global
parameter allows the entire
calling environment to be encapsulated, including automatic global constants.
sourcepub const fn contains_indexed_global_functions(&self) -> bool
pub const fn contains_indexed_global_functions(&self) -> bool
Does the Module
contain indexed functions that have been exposed to the global namespace?
§Panics
Panics if the Module
is not yet indexed via build_index
.
sourcepub fn build_index(&mut self) -> &mut Self
pub fn build_index(&mut self) -> &mut Self
sourcepub fn contains_qualified_iter(&self, id: TypeId) -> bool
pub fn contains_qualified_iter(&self, id: TypeId) -> bool
Does a type iterator exist in the entire module tree?
sourcepub fn contains_iter(&self, id: TypeId) -> bool
pub fn contains_iter(&self, id: TypeId) -> bool
Does a type iterator exist in the module?
sourcepub fn set_iter(
&mut self,
type_id: TypeId,
func: impl Fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + SendSync + 'static
) -> &mut Self
pub fn set_iter( &mut self, type_id: TypeId, func: impl Fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + SendSync + 'static ) -> &mut Self
Set a type iterator into the Module
.
sourcepub fn set_iter_result(
&mut self,
type_id: TypeId,
func: impl Fn(Dynamic) -> Box<dyn Iterator<Item = Result<Dynamic, Box<EvalAltResult>>>> + SendSync + 'static
) -> &mut Self
pub fn set_iter_result( &mut self, type_id: TypeId, func: impl Fn(Dynamic) -> Box<dyn Iterator<Item = Result<Dynamic, Box<EvalAltResult>>>> + SendSync + 'static ) -> &mut Self
Set a fallible type iterator into the Module
.
sourcepub fn set_iterable<T>(&mut self) -> &mut Self
pub fn set_iterable<T>(&mut self) -> &mut Self
Set a type iterator into the Module
.
sourcepub fn set_iterable_result<T, X>(&mut self) -> &mut Self
pub fn set_iterable_result<T, X>(&mut self) -> &mut Self
Set a fallible type iterator into the Module
.
sourcepub fn set_iterator<T>(&mut self) -> &mut Self
pub fn set_iterator<T>(&mut self) -> &mut Self
Set an iterator type into the Module
as a type iterator.
Trait Implementations§
source§impl<M: Into<Self>> AddAssign<M> for Module
impl<M: Into<Self>> AddAssign<M> for Module
source§fn add_assign(&mut self, rhs: M)
fn add_assign(&mut self, rhs: M)
+=
operation. Read moresource§impl<T: Into<Shared<ScriptFuncDef>>> Extend<T> for Module
impl<T: Into<Shared<ScriptFuncDef>>> Extend<T> for Module
source§fn extend<ITER: IntoIterator<Item = T>>(&mut self, iter: ITER)
fn extend<ITER: IntoIterator<Item = T>>(&mut self, iter: ITER)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T: IntoIterator<Item = Shared<ScriptFuncDef>>> From<T> for Module
impl<T: IntoIterator<Item = Shared<ScriptFuncDef>>> From<T> for Module
Auto Trait Implementations§
impl Freeze for Module
impl !RefUnwindSafe for Module
impl !Send for Module
impl !Sync for Module
impl Unpin for Module
impl !UnwindSafe for Module
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Variant for T
impl<T> Variant for T
source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Variant
trait object to &mut dyn Any
.source§fn as_boxed_any(self: Box<T>) -> Box<dyn Any>
fn as_boxed_any(self: Box<T>) -> Box<dyn Any>
Variant
trait object to Box<dyn Any>
.