2020-05-05 06:24:13 +02:00
|
|
|
//! Module defining external-loaded modules for Rhai.
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
use crate::any::{Dynamic, Variant};
|
2020-07-26 09:53:22 +02:00
|
|
|
use crate::engine::Engine;
|
2020-09-28 12:53:03 +02:00
|
|
|
use crate::fn_native::{CallableFunction, FnCallArgs, IteratorFn, SendSync};
|
2020-09-19 12:12:23 +02:00
|
|
|
use crate::fn_register::by_value as cast_arg;
|
2020-10-01 17:31:27 +02:00
|
|
|
use crate::parser::FnAccess;
|
2020-05-05 09:00:10 +02:00
|
|
|
use crate::result::EvalAltResult;
|
2020-05-07 18:19:08 +02:00
|
|
|
use crate::token::{Position, Token};
|
2020-10-10 07:41:55 +02:00
|
|
|
use crate::utils::{ImmutableString, StraightHasherBuilder};
|
|
|
|
use crate::{calc_fn_hash, StaticVec};
|
2020-05-05 06:24:13 +02:00
|
|
|
|
2020-07-26 09:53:22 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-09-24 17:32:54 +02:00
|
|
|
use crate::{fn_native::Shared, parser::ScriptFnDef};
|
2020-07-26 09:53:22 +02:00
|
|
|
|
|
|
|
#[cfg(not(feature = "no_module"))]
|
|
|
|
use crate::{
|
|
|
|
engine::Imports,
|
|
|
|
parser::AST,
|
|
|
|
scope::{Entry as ScopeEntry, Scope},
|
|
|
|
};
|
|
|
|
|
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-09-22 11:57:56 +02:00
|
|
|
use crate::engine::{Array, FN_IDX_GET, FN_IDX_SET};
|
2020-07-26 09:53:22 +02:00
|
|
|
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-09-22 11:57:56 +02:00
|
|
|
use crate::engine::{make_getter, make_setter, Map};
|
2020-07-26 09:53:22 +02:00
|
|
|
|
2020-05-05 17:57:25 +02:00
|
|
|
use crate::stdlib::{
|
2020-05-06 10:09:44 +02:00
|
|
|
any::TypeId,
|
2020-05-06 13:45:17 +02:00
|
|
|
boxed::Box,
|
2020-05-06 10:09:44 +02:00
|
|
|
collections::HashMap,
|
2020-06-26 17:24:47 +02:00
|
|
|
fmt, format,
|
2020-05-19 14:07:51 +02:00
|
|
|
iter::empty,
|
2020-05-08 16:38:56 +02:00
|
|
|
num::NonZeroUsize,
|
2020-10-07 09:40:36 +02:00
|
|
|
ops::{Add, AddAssign, Deref, DerefMut},
|
2020-05-06 13:45:17 +02:00
|
|
|
string::{String, ToString},
|
2020-05-07 18:19:08 +02:00
|
|
|
vec::Vec,
|
2020-05-05 17:57:25 +02:00
|
|
|
};
|
|
|
|
|
2020-05-06 10:09:44 +02:00
|
|
|
/// Return type of module-level Rust function.
|
2020-05-13 13:21:42 +02:00
|
|
|
pub type FuncReturn<T> = Result<T, Box<EvalAltResult>>;
|
2020-05-06 10:09:44 +02:00
|
|
|
|
2020-09-25 12:07:39 +02:00
|
|
|
pub type FuncInfo = (
|
|
|
|
String,
|
|
|
|
FnAccess,
|
|
|
|
usize,
|
|
|
|
Option<StaticVec<TypeId>>,
|
|
|
|
CallableFunction,
|
|
|
|
);
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
/// An imported module, which may contain variables, sub-modules,
|
|
|
|
/// external Rust functions, and script-defined functions.
|
2020-05-05 06:24:13 +02:00
|
|
|
///
|
|
|
|
/// Not available under the `no_module` feature.
|
2020-06-27 17:56:24 +02:00
|
|
|
#[derive(Default)]
|
2020-05-05 09:00:10 +02:00
|
|
|
pub struct Module {
|
|
|
|
/// Sub-modules.
|
|
|
|
modules: HashMap<String, Module>,
|
2020-05-07 18:19:08 +02:00
|
|
|
|
|
|
|
/// Module variables.
|
2020-05-05 09:00:10 +02:00
|
|
|
variables: HashMap<String, Dynamic>,
|
2020-05-05 17:57:25 +02:00
|
|
|
|
2020-05-07 18:19:08 +02:00
|
|
|
/// Flattened collection of all module variables, including those in sub-modules.
|
2020-05-30 18:02:23 +02:00
|
|
|
all_variables: HashMap<u64, Dynamic, StraightHasherBuilder>,
|
2020-05-07 18:19:08 +02:00
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
/// External Rust functions.
|
2020-09-25 12:07:39 +02:00
|
|
|
functions: HashMap<u64, FuncInfo, StraightHasherBuilder>,
|
2020-05-05 17:57:25 +02:00
|
|
|
|
2020-05-13 13:21:42 +02:00
|
|
|
/// Iterator functions, keyed by the type producing the iterator.
|
2020-05-20 13:27:23 +02:00
|
|
|
type_iterators: HashMap<TypeId, IteratorFn>,
|
2020-05-19 13:03:06 +02:00
|
|
|
|
|
|
|
/// Flattened collection of all external Rust functions, native or scripted,
|
|
|
|
/// including those in sub-modules.
|
2020-09-25 12:07:39 +02:00
|
|
|
all_functions: HashMap<u64, CallableFunction, StraightHasherBuilder>,
|
2020-06-27 17:56:24 +02:00
|
|
|
|
|
|
|
/// Is the module indexed?
|
|
|
|
indexed: bool,
|
2020-05-05 09:00:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Debug for Module {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
write!(
|
|
|
|
f,
|
2020-06-27 17:56:24 +02:00
|
|
|
"Module(\n modules: {}\n vars: {}\n functions: {}\n)",
|
|
|
|
self.modules
|
|
|
|
.keys()
|
2020-10-01 17:31:27 +02:00
|
|
|
.map(String::as_str)
|
2020-06-27 17:56:24 +02:00
|
|
|
.collect::<Vec<_>>()
|
|
|
|
.join(", "),
|
|
|
|
self.variables
|
|
|
|
.iter()
|
|
|
|
.map(|(k, v)| format!("{}={:?}", k, v))
|
|
|
|
.collect::<Vec<_>>()
|
|
|
|
.join(", "),
|
|
|
|
self.functions
|
|
|
|
.values()
|
2020-09-24 16:50:28 +02:00
|
|
|
.map(|(_, _, _, _, f)| f.to_string())
|
2020-06-27 17:56:24 +02:00
|
|
|
.collect::<Vec<_>>()
|
|
|
|
.join(", "),
|
2020-05-05 09:00:10 +02:00
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-27 17:56:24 +02:00
|
|
|
impl Clone for Module {
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-06-27 17:56:24 +02:00
|
|
|
fn clone(&self) -> Self {
|
|
|
|
// Only clone the index at the top level
|
|
|
|
Self {
|
|
|
|
all_variables: self.all_variables.clone(),
|
|
|
|
all_functions: self.all_functions.clone(),
|
|
|
|
indexed: self.indexed,
|
|
|
|
..self.do_clone(false)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-06 07:01:57 +02:00
|
|
|
impl AsRef<Module> for Module {
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-07-06 07:01:57 +02:00
|
|
|
fn as_ref(&self) -> &Module {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-05 06:24:13 +02:00
|
|
|
impl Module {
|
|
|
|
/// Create a new module.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 06:24:13 +02:00
|
|
|
pub fn new() -> Self {
|
2020-05-05 09:00:10 +02:00
|
|
|
Default::default()
|
2020-05-05 06:24:13 +02:00
|
|
|
}
|
|
|
|
|
2020-05-13 13:39:34 +02:00
|
|
|
/// Create a new module with a specified capacity for native Rust functions.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-13 13:39:34 +02:00
|
|
|
pub fn new_with_capacity(capacity: usize) -> Self {
|
|
|
|
Self {
|
2020-05-30 18:02:23 +02:00
|
|
|
functions: HashMap::with_capacity_and_hasher(capacity, StraightHasherBuilder),
|
2020-05-13 13:39:34 +02:00
|
|
|
..Default::default()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-30 03:57:21 +02:00
|
|
|
/// Is the module empty?
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let module = Module::new();
|
|
|
|
/// assert!(module.is_empty());
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-09-30 03:57:21 +02:00
|
|
|
pub fn is_empty(&self) -> bool {
|
|
|
|
self.functions.is_empty()
|
|
|
|
&& self.all_functions.is_empty()
|
|
|
|
&& self.variables.is_empty()
|
|
|
|
&& self.all_variables.is_empty()
|
|
|
|
&& self.modules.is_empty()
|
|
|
|
&& self.type_iterators.is_empty()
|
|
|
|
}
|
|
|
|
|
2020-06-27 17:56:24 +02:00
|
|
|
/// Clone the module, optionally skipping the index.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-06-27 17:56:24 +02:00
|
|
|
fn do_clone(&self, clone_index: bool) -> Self {
|
|
|
|
Self {
|
|
|
|
modules: if clone_index {
|
|
|
|
self.modules.clone()
|
|
|
|
} else {
|
|
|
|
self.modules
|
|
|
|
.iter()
|
|
|
|
.map(|(k, m)| (k.clone(), m.do_clone(clone_index)))
|
|
|
|
.collect()
|
|
|
|
},
|
|
|
|
variables: self.variables.clone(),
|
|
|
|
functions: self.functions.clone(),
|
|
|
|
type_iterators: self.type_iterators.clone(),
|
|
|
|
..Default::default()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
/// Does a variable exist in the module?
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert!(module.contains_var("answer"));
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub fn contains_var(&self, name: &str) -> bool {
|
2020-05-05 09:00:10 +02:00
|
|
|
self.variables.contains_key(name)
|
2020-05-05 06:24:13 +02:00
|
|
|
}
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
/// Get the value of a module variable.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub fn get_var_value<T: Variant + Clone>(&self, name: &str) -> Option<T> {
|
2020-05-07 18:19:08 +02:00
|
|
|
self.get_var(name).and_then(Dynamic::try_cast::<T>)
|
2020-05-05 09:00:10 +02:00
|
|
|
}
|
|
|
|
|
2020-05-06 13:45:17 +02:00
|
|
|
/// Get a module variable as a `Dynamic`.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert_eq!(module.get_var("answer").unwrap().cast::<i64>(), 42);
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub fn get_var(&self, name: &str) -> Option<Dynamic> {
|
2020-05-05 09:00:10 +02:00
|
|
|
self.variables.get(name).cloned()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a variable into the module.
|
|
|
|
///
|
|
|
|
/// If there is an existing variable of the same name, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// module.set_var("answer", 42_i64);
|
|
|
|
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-07-12 05:46:53 +02:00
|
|
|
pub fn set_var(&mut self, name: impl Into<String>, value: impl Variant + Clone) -> &mut Self {
|
2020-05-13 13:21:42 +02:00
|
|
|
self.variables.insert(name.into(), Dynamic::from(value));
|
2020-06-27 17:56:24 +02:00
|
|
|
self.indexed = false;
|
2020-07-12 05:46:53 +02:00
|
|
|
self
|
2020-05-05 09:00:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get a mutable reference to a modules-qualified variable.
|
2020-06-28 09:49:24 +02:00
|
|
|
/// Name and Position in `EvalAltResult` are None and must be set afterwards.
|
2020-05-07 18:19:08 +02:00
|
|
|
///
|
|
|
|
/// The `u64` hash is calculated by the function `crate::calc_fn_hash`.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub(crate) fn get_qualified_var_mut(
|
2020-05-05 09:00:10 +02:00
|
|
|
&mut self,
|
2020-05-11 17:48:50 +02:00
|
|
|
hash_var: u64,
|
2020-05-05 09:00:10 +02:00
|
|
|
) -> Result<&mut Dynamic, Box<EvalAltResult>> {
|
2020-09-11 16:32:59 +02:00
|
|
|
if hash_var == 0 {
|
|
|
|
Err(EvalAltResult::ErrorVariableNotFound(String::new(), Position::none()).into())
|
|
|
|
} else {
|
|
|
|
self.all_variables.get_mut(&hash_var).ok_or_else(|| {
|
|
|
|
EvalAltResult::ErrorVariableNotFound(String::new(), Position::none()).into()
|
|
|
|
})
|
|
|
|
}
|
2020-05-05 09:00:10 +02:00
|
|
|
}
|
|
|
|
|
2020-06-05 09:14:42 +02:00
|
|
|
/// 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.
|
2020-09-24 17:32:54 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-09-24 16:50:28 +02:00
|
|
|
pub(crate) fn set_script_fn(&mut self, fn_def: ScriptFnDef) -> u64 {
|
2020-06-05 09:14:42 +02:00
|
|
|
// None + function name + number of arguments.
|
2020-09-24 16:50:28 +02:00
|
|
|
let num_params = fn_def.params.len();
|
|
|
|
let hash_script = calc_fn_hash(empty(), &fn_def.name, num_params, empty());
|
2020-06-05 09:14:42 +02:00
|
|
|
self.functions.insert(
|
2020-06-11 12:13:33 +02:00
|
|
|
hash_script,
|
2020-06-05 09:14:42 +02:00
|
|
|
(
|
|
|
|
fn_def.name.to_string(),
|
|
|
|
fn_def.access,
|
2020-09-24 16:50:28 +02:00
|
|
|
num_params,
|
|
|
|
None,
|
2020-06-05 09:14:42 +02:00
|
|
|
fn_def.into(),
|
|
|
|
),
|
|
|
|
);
|
2020-06-27 17:56:24 +02:00
|
|
|
self.indexed = false;
|
2020-09-24 16:50:28 +02:00
|
|
|
hash_script
|
2020-06-05 09:14:42 +02:00
|
|
|
}
|
|
|
|
|
2020-10-05 04:27:31 +02:00
|
|
|
/// Get a script-defined function in the module based on name and number of parameters.
|
2020-10-05 06:09:45 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-10-05 04:27:31 +02:00
|
|
|
pub fn get_script_fn(
|
|
|
|
&self,
|
|
|
|
name: &str,
|
|
|
|
num_params: usize,
|
|
|
|
public_only: bool,
|
|
|
|
) -> Option<&Shared<ScriptFnDef>> {
|
|
|
|
self.functions
|
|
|
|
.values()
|
|
|
|
.find(|(fn_name, access, num, _, _)| {
|
|
|
|
(!public_only || *access == FnAccess::Public)
|
|
|
|
&& *num == num_params
|
|
|
|
&& fn_name == name
|
|
|
|
})
|
|
|
|
.map(|(_, _, _, _, f)| f.get_shared_fn_def())
|
|
|
|
}
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
/// Does a sub-module exist in the module?
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let sub_module = Module::new();
|
|
|
|
/// module.set_sub_module("question", sub_module);
|
|
|
|
/// assert!(module.contains_sub_module("question"));
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 09:00:10 +02:00
|
|
|
pub fn contains_sub_module(&self, name: &str) -> bool {
|
|
|
|
self.modules.contains_key(name)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get a sub-module.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let sub_module = Module::new();
|
|
|
|
/// module.set_sub_module("question", sub_module);
|
|
|
|
/// assert!(module.get_sub_module("question").is_some());
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 09:00:10 +02:00
|
|
|
pub fn get_sub_module(&self, name: &str) -> Option<&Module> {
|
|
|
|
self.modules.get(name)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get a mutable reference to a sub-module.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let sub_module = Module::new();
|
|
|
|
/// module.set_sub_module("question", sub_module);
|
|
|
|
/// assert!(module.get_sub_module_mut("question").is_some());
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-05-05 09:00:10 +02:00
|
|
|
pub fn get_sub_module_mut(&mut self, name: &str) -> Option<&mut Module> {
|
|
|
|
self.modules.get_mut(name)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a sub-module into the module.
|
|
|
|
///
|
|
|
|
/// If there is an existing sub-module of the same name, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let sub_module = Module::new();
|
|
|
|
/// module.set_sub_module("question", sub_module);
|
|
|
|
/// assert!(module.get_sub_module("question").is_some());
|
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-07-12 05:46:53 +02:00
|
|
|
pub fn set_sub_module(&mut self, name: impl Into<String>, sub_module: Module) -> &mut Self {
|
2020-05-05 09:00:10 +02:00
|
|
|
self.modules.insert(name.into(), sub_module.into());
|
2020-06-27 17:56:24 +02:00
|
|
|
self.indexed = false;
|
2020-07-12 05:46:53 +02:00
|
|
|
self
|
2020-05-05 09:00:10 +02:00
|
|
|
}
|
|
|
|
|
2020-05-05 11:51:40 +02:00
|
|
|
/// Does the particular Rust function exist in the module?
|
|
|
|
///
|
|
|
|
/// The `u64` hash is calculated by the function `crate::calc_fn_hash`.
|
|
|
|
/// It is also returned by the `set_fn_XXX` calls.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-09 18:19:13 +02:00
|
|
|
/// let hash = module.set_fn_0("calc", || Ok(42_i64));
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-07-27 12:10:45 +02:00
|
|
|
pub fn contains_fn(&self, hash_fn: u64, public_only: bool) -> bool {
|
2020-09-11 16:32:59 +02:00
|
|
|
if hash_fn == 0 {
|
|
|
|
false
|
|
|
|
} else if public_only {
|
2020-07-27 12:10:45 +02:00
|
|
|
self.functions
|
|
|
|
.get(&hash_fn)
|
2020-10-01 17:31:27 +02:00
|
|
|
.map(|(_, access, _, _, _)| access.is_public())
|
2020-07-27 12:10:45 +02:00
|
|
|
.unwrap_or(false)
|
|
|
|
} else {
|
|
|
|
self.functions.contains_key(&hash_fn)
|
|
|
|
}
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a Rust function into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is an existing Rust function of the same hash, it is replaced.
|
2020-07-11 09:09:17 +02:00
|
|
|
///
|
|
|
|
/// ## WARNING - Low Level API
|
|
|
|
///
|
|
|
|
/// This function is very low level.
|
|
|
|
pub fn set_fn(
|
2020-05-22 15:50:24 +02:00
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
|
|
|
access: FnAccess,
|
2020-07-07 16:59:23 +02:00
|
|
|
arg_types: &[TypeId],
|
2020-09-25 12:07:39 +02:00
|
|
|
func: CallableFunction,
|
2020-05-22 15:50:24 +02:00
|
|
|
) -> u64 {
|
|
|
|
let name = name.into();
|
|
|
|
|
2020-09-11 16:32:59 +02:00
|
|
|
let args_len = if arg_types.is_empty() {
|
|
|
|
// Distinguish between a script function and a function with no parameters
|
|
|
|
usize::MAX
|
|
|
|
} else {
|
|
|
|
arg_types.len()
|
|
|
|
};
|
|
|
|
|
2020-09-19 12:12:23 +02:00
|
|
|
let params = arg_types
|
|
|
|
.into_iter()
|
|
|
|
.cloned()
|
|
|
|
.map(|id| {
|
|
|
|
if id == TypeId::of::<&str>() {
|
|
|
|
TypeId::of::<ImmutableString>()
|
|
|
|
} else if id == TypeId::of::<String>() {
|
|
|
|
TypeId::of::<ImmutableString>()
|
|
|
|
} else {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
2020-05-05 17:57:25 +02:00
|
|
|
|
2020-09-19 12:12:23 +02:00
|
|
|
let hash_fn = calc_fn_hash(empty(), &name, args_len, arg_types.iter().cloned());
|
2020-05-17 16:19:49 +02:00
|
|
|
|
2020-05-19 13:03:06 +02:00
|
|
|
self.functions
|
2020-09-24 16:50:28 +02:00
|
|
|
.insert(hash_fn, (name, access, args_len, Some(params), func.into()));
|
2020-05-05 17:57:25 +02:00
|
|
|
|
2020-06-27 17:56:24 +02:00
|
|
|
self.indexed = false;
|
|
|
|
|
2020-05-11 17:48:50 +02:00
|
|
|
hash_fn
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 16:59:23 +02:00
|
|
|
/// Set a Rust function taking a reference to the scripting `Engine`, the current set of functions,
|
|
|
|
/// plus a list of mutable `Dynamic` references into the module, returning a hash key.
|
2020-06-15 15:49:02 +02:00
|
|
|
///
|
|
|
|
/// Use this to register a built-in function which must reference settings on the scripting
|
2020-07-07 16:59:23 +02:00
|
|
|
/// `Engine` (e.g. to prevent growing an array beyond the allowed maximum size), or to call a
|
|
|
|
/// script-defined function in the current evaluation context.
|
2020-06-15 15:49:02 +02:00
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-07-07 16:59:23 +02:00
|
|
|
///
|
|
|
|
/// ## WARNING - Low Level API
|
|
|
|
///
|
|
|
|
/// This function is very low level.
|
|
|
|
///
|
|
|
|
/// A list of `TypeId`'s is taken as the argument types.
|
|
|
|
///
|
|
|
|
/// Arguments are simply passed in as a mutable array of `&mut Dynamic`,
|
|
|
|
/// which is guaranteed to contain enough arguments of the correct types.
|
|
|
|
///
|
2020-10-03 10:25:58 +02:00
|
|
|
/// The function is assumed to be a _method_, meaning that the first argument should not be consumed.
|
|
|
|
/// All other arguments can be consumed.
|
|
|
|
///
|
2020-07-07 16:59:23 +02:00
|
|
|
/// To access a primary parameter value (i.e. cloning is cheap), use: `args[n].clone().cast::<T>()`
|
|
|
|
///
|
|
|
|
/// To access a parameter value and avoid cloning, use `std::mem::take(args[n]).cast::<T>()`.
|
|
|
|
/// Notice that this will _consume_ the argument, replacing it with `()`.
|
|
|
|
///
|
|
|
|
/// To access the first mutable parameter, use `args.get_mut(0).unwrap()`
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let hash = module.set_raw_fn("double_or_not",
|
|
|
|
/// // Pass parameter types via a slice with TypeId's
|
2020-07-28 04:25:57 +02:00
|
|
|
/// &[std::any::TypeId::of::<i64>(), std::any::TypeId::of::<bool>()],
|
2020-07-07 16:59:23 +02:00
|
|
|
/// // Fixed closure signature
|
|
|
|
/// |engine, lib, args| {
|
|
|
|
/// // 'args' is guaranteed to be the right length and of the correct types
|
|
|
|
///
|
|
|
|
/// // Get the second parameter by 'consuming' it
|
|
|
|
/// let double = std::mem::take(args[1]).cast::<bool>();
|
|
|
|
/// // Since it is a primary type, it can also be cheaply copied
|
|
|
|
/// let double = args[1].clone().cast::<bool>();
|
|
|
|
/// // Get a mutable reference to the first argument.
|
2020-07-27 06:30:09 +02:00
|
|
|
/// let mut x = args[0].write_lock::<i64>().unwrap();
|
2020-07-07 16:59:23 +02:00
|
|
|
///
|
|
|
|
/// let orig = *x;
|
|
|
|
///
|
|
|
|
/// if double {
|
|
|
|
/// *x *= 2; // the first argument can be mutated
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// Ok(orig) // return Result<T, Box<EvalAltResult>>
|
|
|
|
/// });
|
|
|
|
///
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-07-07 16:59:23 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-07-07 16:59:23 +02:00
|
|
|
pub fn set_raw_fn<T: Variant + Clone>(
|
2020-06-15 15:49:02 +02:00
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-07-07 16:59:23 +02:00
|
|
|
arg_types: &[TypeId],
|
2020-07-06 06:04:02 +02:00
|
|
|
func: impl Fn(&Engine, &Module, &mut [&mut Dynamic]) -> FuncReturn<T> + SendSync + 'static,
|
2020-06-15 15:49:02 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |engine: &Engine, lib: &Module, args: &mut FnCallArgs| {
|
|
|
|
func(engine, lib, args).map(Dynamic::from)
|
|
|
|
};
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
arg_types,
|
|
|
|
CallableFunction::from_method(Box::new(f)),
|
|
|
|
)
|
2020-06-15 15:49:02 +02:00
|
|
|
}
|
|
|
|
|
2020-09-25 04:59:21 +02:00
|
|
|
/// Set a raw function but with a signature that is a scripted function (meaning that the types
|
|
|
|
/// are not determined), but the implementation is in Rust.
|
2020-09-24 17:32:54 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-09-25 04:59:21 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-09-24 16:50:28 +02:00
|
|
|
pub(crate) fn set_raw_fn_as_scripted(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-10-02 17:14:33 +02:00
|
|
|
num_params: usize,
|
2020-09-24 16:50:28 +02:00
|
|
|
func: impl Fn(&Engine, &Module, &mut [&mut Dynamic]) -> FuncReturn<Dynamic> + SendSync + 'static,
|
|
|
|
) -> u64 {
|
|
|
|
// None + function name + number of arguments.
|
|
|
|
let name = name.into();
|
2020-10-02 17:14:33 +02:00
|
|
|
let hash_script = calc_fn_hash(empty(), &name, num_params, empty());
|
2020-09-24 16:50:28 +02:00
|
|
|
let f = move |engine: &Engine, lib: &Module, args: &mut FnCallArgs| func(engine, lib, args);
|
|
|
|
self.functions.insert(
|
|
|
|
hash_script,
|
|
|
|
(
|
|
|
|
name,
|
|
|
|
FnAccess::Public,
|
2020-10-02 17:14:33 +02:00
|
|
|
num_params,
|
2020-09-24 16:50:28 +02:00
|
|
|
None,
|
2020-09-25 12:07:39 +02:00
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
2020-09-24 16:50:28 +02:00
|
|
|
),
|
|
|
|
);
|
|
|
|
self.indexed = false;
|
|
|
|
hash_script
|
|
|
|
}
|
|
|
|
|
2020-05-05 11:51:40 +02:00
|
|
|
/// Set a Rust function taking no parameters into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-09 18:19:13 +02:00
|
|
|
/// let hash = module.set_fn_0("calc", || Ok(42_i64));
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-22 15:50:24 +02:00
|
|
|
pub fn set_fn_0<T: Variant + Clone>(
|
2020-05-05 11:51:40 +02:00
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn() -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, _: &mut FnCallArgs| func().map(Dynamic::from);
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a Rust function taking one parameter into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-09 18:19:13 +02:00
|
|
|
/// let hash = module.set_fn_1("calc", |x: i64| Ok(x + 1));
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-22 15:50:24 +02:00
|
|
|
pub fn set_fn_1<A: Variant + Clone, T: Variant + Clone>(
|
2020-05-05 11:51:40 +02:00
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(A) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
func(cast_arg::<A>(&mut args[0])).map(Dynamic::from)
|
2020-06-15 15:49:02 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a Rust function taking one mutable parameter into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-09 18:19:13 +02:00
|
|
|
/// let hash = module.set_fn_1_mut("calc", |x: &mut i64| { *x += 1; Ok(*x) });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-22 15:50:24 +02:00
|
|
|
pub fn set_fn_1_mut<A: Variant + Clone, T: Variant + Clone>(
|
2020-05-05 11:51:40 +02:00
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-07-27 06:30:09 +02:00
|
|
|
func(&mut args[0].write_lock::<A>().unwrap()).map(Dynamic::from)
|
2020-05-05 11:51:40 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_method(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
2020-05-30 04:28:17 +02:00
|
|
|
/// Set a Rust getter function taking one mutable parameter, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust getter function, it is replaced.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::Module;
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let hash = module.set_getter_fn("value", |x: &mut i64| { Ok(*x) });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-30 04:28:17 +02:00
|
|
|
/// ```
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-30 04:28:17 +02:00
|
|
|
pub fn set_getter_fn<A: Variant + Clone, T: Variant + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-30 04:28:17 +02:00
|
|
|
) -> u64 {
|
|
|
|
self.set_fn_1_mut(make_getter(&name.into()), func)
|
|
|
|
}
|
|
|
|
|
2020-05-05 11:51:40 +02:00
|
|
|
/// Set a Rust function taking two parameters into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_2("calc", |x: i64, y: ImmutableString| {
|
2020-05-06 13:45:17 +02:00
|
|
|
/// Ok(x + y.len() as i64)
|
2020-05-09 18:19:13 +02:00
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-22 15:50:24 +02:00
|
|
|
pub fn set_fn_2<A: Variant + Clone, B: Variant + Clone, T: Variant + Clone>(
|
2020-05-05 11:51:40 +02:00
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(A, B) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let a = cast_arg::<A>(&mut args[0]);
|
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
2020-05-05 11:51:40 +02:00
|
|
|
|
2020-05-13 15:58:38 +02:00
|
|
|
func(a, b).map(Dynamic::from)
|
2020-05-05 11:51:40 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>(), TypeId::of::<B>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a Rust function taking two parameters (the first one mutable) into the module,
|
|
|
|
/// returning a hash key.
|
|
|
|
///
|
2020-05-30 04:28:17 +02:00
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
|
|
|
///
|
2020-05-06 13:45:17 +02:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_2_mut("calc", |x: &mut i64, y: ImmutableString| {
|
2020-05-06 13:45:17 +02:00
|
|
|
/// *x += y.len() as i64; Ok(*x)
|
2020-05-09 18:19:13 +02:00
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-22 15:50:24 +02:00
|
|
|
pub fn set_fn_2_mut<A: Variant + Clone, B: Variant + Clone, T: Variant + Clone>(
|
2020-05-05 11:51:40 +02:00
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A, B) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
2020-08-11 07:46:09 +02:00
|
|
|
let a = &mut args[0].write_lock::<A>().unwrap();
|
2020-05-05 11:51:40 +02:00
|
|
|
|
2020-08-11 07:46:09 +02:00
|
|
|
func(a, b).map(Dynamic::from)
|
2020-05-05 11:51:40 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>(), TypeId::of::<B>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_method(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
2020-05-30 04:28:17 +02:00
|
|
|
/// Set a Rust setter function taking two parameters (the first one mutable) into the module,
|
|
|
|
/// returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing setter Rust function, it is replaced.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// 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(())
|
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-30 04:28:17 +02:00
|
|
|
/// ```
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-30 04:28:17 +02:00
|
|
|
pub fn set_setter_fn<A: Variant + Clone, B: Variant + Clone>(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A, B) -> FuncReturn<()> + SendSync + 'static,
|
2020-05-30 04:28:17 +02:00
|
|
|
) -> u64 {
|
|
|
|
self.set_fn_2_mut(make_setter(&name.into()), func)
|
|
|
|
}
|
|
|
|
|
2020-06-06 07:06:00 +02:00
|
|
|
/// Set a Rust index getter taking two parameters (the first one mutable) into the module,
|
2020-05-30 04:28:17 +02:00
|
|
|
/// returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing setter Rust function, it is replaced.
|
|
|
|
///
|
2020-09-22 11:57:56 +02:00
|
|
|
/// # Panics
|
|
|
|
///
|
|
|
|
/// Panics if the type is `Array` or `Map`.
|
|
|
|
/// Indexers for arrays, object maps and strings cannot be registered.
|
|
|
|
///
|
2020-05-30 04:28:17 +02:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::{Module, ImmutableString};
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-06-06 07:06:00 +02:00
|
|
|
/// let hash = module.set_indexer_get_fn(|x: &mut i64, y: ImmutableString| {
|
2020-05-30 04:28:17 +02:00
|
|
|
/// Ok(*x + y.len() as i64)
|
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-30 04:28:17 +02:00
|
|
|
/// ```
|
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-06-06 07:06:00 +02:00
|
|
|
pub fn set_indexer_get_fn<A: Variant + Clone, B: Variant + Clone, T: Variant + Clone>(
|
2020-05-30 04:28:17 +02:00
|
|
|
&mut self,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A, B) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-30 04:28:17 +02:00
|
|
|
) -> u64 {
|
2020-09-22 11:57:56 +02:00
|
|
|
if TypeId::of::<A>() == TypeId::of::<Array>() {
|
|
|
|
panic!("Cannot register indexer for arrays.");
|
|
|
|
}
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
|
|
|
if TypeId::of::<A>() == TypeId::of::<Map>() {
|
|
|
|
panic!("Cannot register indexer for object maps.");
|
|
|
|
}
|
|
|
|
if TypeId::of::<A>() == TypeId::of::<String>()
|
|
|
|
|| TypeId::of::<A>() == TypeId::of::<&str>()
|
|
|
|
|| TypeId::of::<A>() == TypeId::of::<ImmutableString>()
|
|
|
|
{
|
|
|
|
panic!("Cannot register indexer for strings.");
|
|
|
|
}
|
|
|
|
|
2020-06-25 05:07:46 +02:00
|
|
|
self.set_fn_2_mut(FN_IDX_GET, func)
|
2020-05-30 04:28:17 +02:00
|
|
|
}
|
|
|
|
|
2020-05-05 11:51:40 +02:00
|
|
|
/// Set a Rust function taking three parameters into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_3("calc", |x: i64, y: ImmutableString, z: i64| {
|
2020-05-06 13:45:17 +02:00
|
|
|
/// Ok(x + y.len() as i64 + z)
|
2020-05-09 18:19:13 +02:00
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub fn set_fn_3<
|
|
|
|
A: Variant + Clone,
|
|
|
|
B: Variant + Clone,
|
|
|
|
C: Variant + Clone,
|
2020-05-13 13:21:42 +02:00
|
|
|
T: Variant + Clone,
|
2020-05-05 11:51:40 +02:00
|
|
|
>(
|
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(A, B, C) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let a = cast_arg::<A>(&mut args[0]);
|
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
|
|
|
let c = cast_arg::<C>(&mut args[2]);
|
2020-05-05 11:51:40 +02:00
|
|
|
|
2020-05-13 15:58:38 +02:00
|
|
|
func(a, b, c).map(Dynamic::from)
|
2020-05-05 11:51:40 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a Rust function taking three parameters (the first one mutable) into the module,
|
|
|
|
/// returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_3_mut("calc", |x: &mut i64, y: ImmutableString, z: i64| {
|
2020-05-06 13:45:17 +02:00
|
|
|
/// *x += y.len() as i64 + z; Ok(*x)
|
2020-05-09 18:19:13 +02:00
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-06 13:45:17 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-05 11:51:40 +02:00
|
|
|
pub fn set_fn_3_mut<
|
|
|
|
A: Variant + Clone,
|
|
|
|
B: Variant + Clone,
|
|
|
|
C: Variant + Clone,
|
2020-05-13 13:21:42 +02:00
|
|
|
T: Variant + Clone,
|
2020-05-05 11:51:40 +02:00
|
|
|
>(
|
|
|
|
&mut self,
|
2020-05-22 15:50:24 +02:00
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A, B, C) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-05 11:51:40 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let b = cast_arg::<B>(&mut args[2]);
|
|
|
|
let c = cast_arg::<C>(&mut args[3]);
|
2020-08-11 07:46:09 +02:00
|
|
|
let a = &mut args[0].write_lock::<A>().unwrap();
|
2020-05-05 11:51:40 +02:00
|
|
|
|
2020-08-11 07:46:09 +02:00
|
|
|
func(a, b, c).map(Dynamic::from)
|
2020-05-05 11:51:40 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_method(Box::new(f)),
|
|
|
|
)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
2020-06-06 07:06:00 +02:00
|
|
|
/// Set a Rust index setter taking three parameters (the first one mutable) into the module,
|
|
|
|
/// returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
|
|
|
///
|
2020-09-22 11:57:56 +02:00
|
|
|
/// # Panics
|
|
|
|
///
|
|
|
|
/// Panics if the type is `Array` or `Map`.
|
|
|
|
/// Indexers for arrays, object maps and strings cannot be registered.
|
|
|
|
///
|
2020-06-06 07:06:00 +02:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::{Module, ImmutableString};
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let hash = module.set_indexer_set_fn(|x: &mut i64, y: ImmutableString, value: i64| {
|
|
|
|
/// *x = y.len() as i64 + value;
|
|
|
|
/// Ok(())
|
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-06-06 07:06:00 +02:00
|
|
|
/// ```
|
2020-07-26 09:53:22 +02:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-07-24 17:16:54 +02:00
|
|
|
pub fn set_indexer_set_fn<A: Variant + Clone, B: Variant + Clone, C: Variant + Clone>(
|
2020-06-06 07:06:00 +02:00
|
|
|
&mut self,
|
2020-07-24 17:16:54 +02:00
|
|
|
func: impl Fn(&mut A, B, C) -> FuncReturn<()> + SendSync + 'static,
|
2020-06-06 07:06:00 +02:00
|
|
|
) -> u64 {
|
2020-09-22 11:57:56 +02:00
|
|
|
if TypeId::of::<A>() == TypeId::of::<Array>() {
|
|
|
|
panic!("Cannot register indexer for arrays.");
|
|
|
|
}
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
|
|
|
if TypeId::of::<A>() == TypeId::of::<Map>() {
|
|
|
|
panic!("Cannot register indexer for object maps.");
|
|
|
|
}
|
|
|
|
if TypeId::of::<A>() == TypeId::of::<String>()
|
|
|
|
|| TypeId::of::<A>() == TypeId::of::<&str>()
|
|
|
|
|| TypeId::of::<A>() == TypeId::of::<ImmutableString>()
|
|
|
|
{
|
|
|
|
panic!("Cannot register indexer for strings.");
|
|
|
|
}
|
|
|
|
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
|
|
|
let c = cast_arg::<C>(&mut args[2]);
|
2020-08-11 07:46:09 +02:00
|
|
|
let a = &mut args[0].write_lock::<A>().unwrap();
|
2020-06-06 07:06:00 +02:00
|
|
|
|
2020-08-11 07:46:09 +02:00
|
|
|
func(a, b, c).map(Dynamic::from)
|
2020-06-06 07:06:00 +02:00
|
|
|
};
|
2020-07-24 17:16:54 +02:00
|
|
|
let arg_types = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
|
2020-06-06 07:06:00 +02:00
|
|
|
self.set_fn(
|
2020-06-25 05:07:46 +02:00
|
|
|
FN_IDX_SET,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-07-07 16:59:23 +02:00
|
|
|
&arg_types,
|
2020-09-25 12:07:39 +02:00
|
|
|
CallableFunction::from_method(Box::new(f)),
|
2020-06-06 07:06:00 +02:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2020-07-24 17:16:54 +02:00
|
|
|
/// Set a pair of Rust index getter and setter functions, returning both hash keys.
|
2020-09-20 08:52:38 +02:00
|
|
|
/// This is a short-hand for `set_indexer_get_fn` and `set_indexer_set_fn`.
|
2020-07-24 17:16:54 +02:00
|
|
|
///
|
|
|
|
/// If there are similar existing Rust functions, they are replaced.
|
|
|
|
///
|
2020-09-22 11:57:56 +02:00
|
|
|
/// # Panics
|
|
|
|
///
|
|
|
|
/// Panics if the type is `Array` or `Map`.
|
|
|
|
/// Indexers for arrays, object maps and strings cannot be registered.
|
|
|
|
///
|
2020-07-24 17:16:54 +02:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// use rhai::{Module, ImmutableString};
|
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
|
|
|
/// let (hash_get, hash_set) = module.set_indexer_get_set_fn(
|
|
|
|
/// |x: &mut i64, y: ImmutableString| {
|
|
|
|
/// Ok(*x + y.len() as i64)
|
|
|
|
/// },
|
|
|
|
/// |x: &mut i64, y: ImmutableString, value: i64| {
|
|
|
|
/// *x = y.len() as i64 + value;
|
|
|
|
/// Ok(())
|
|
|
|
/// }
|
|
|
|
/// );
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash_get, true));
|
|
|
|
/// assert!(module.contains_fn(hash_set, true));
|
2020-07-24 17:16:54 +02:00
|
|
|
/// ```
|
2020-07-26 09:53:22 +02:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-07-24 17:16:54 +02:00
|
|
|
pub fn set_indexer_get_set_fn<A: Variant + Clone, B: Variant + Clone, T: Variant + Clone>(
|
|
|
|
&mut self,
|
|
|
|
getter: impl Fn(&mut A, B) -> FuncReturn<T> + SendSync + 'static,
|
|
|
|
setter: impl Fn(&mut A, B, T) -> FuncReturn<()> + SendSync + 'static,
|
|
|
|
) -> (u64, u64) {
|
|
|
|
(
|
|
|
|
self.set_indexer_get_fn(getter),
|
|
|
|
self.set_indexer_set_fn(setter),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2020-05-28 08:07:34 +02:00
|
|
|
/// Set a Rust function taking four parameters into the module, returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-28 08:07:34 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_4("calc", |x: i64, y: ImmutableString, z: i64, _w: ()| {
|
2020-05-28 08:07:34 +02:00
|
|
|
/// Ok(x + y.len() as i64 + z)
|
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-28 08:07:34 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-28 08:07:34 +02:00
|
|
|
pub fn set_fn_4<
|
|
|
|
A: Variant + Clone,
|
|
|
|
B: Variant + Clone,
|
|
|
|
C: Variant + Clone,
|
|
|
|
D: Variant + Clone,
|
|
|
|
T: Variant + Clone,
|
|
|
|
>(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(A, B, C, D) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-28 08:07:34 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let a = cast_arg::<A>(&mut args[0]);
|
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
|
|
|
let c = cast_arg::<C>(&mut args[2]);
|
|
|
|
let d = cast_arg::<D>(&mut args[3]);
|
2020-05-28 08:07:34 +02:00
|
|
|
|
|
|
|
func(a, b, c, d).map(Dynamic::from)
|
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [
|
2020-05-28 08:07:34 +02:00
|
|
|
TypeId::of::<A>(),
|
|
|
|
TypeId::of::<B>(),
|
|
|
|
TypeId::of::<C>(),
|
|
|
|
TypeId::of::<D>(),
|
|
|
|
];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_pure(Box::new(f)),
|
|
|
|
)
|
2020-05-28 08:07:34 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 12:15:58 +02:00
|
|
|
/// Set a Rust function taking four parameters (the first one mutable) into the module,
|
2020-05-28 08:07:34 +02:00
|
|
|
/// returning a hash key.
|
|
|
|
///
|
|
|
|
/// If there is a similar existing Rust function, it is replaced.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
2020-05-30 04:28:17 +02:00
|
|
|
/// use rhai::{Module, ImmutableString};
|
2020-05-28 08:07:34 +02:00
|
|
|
///
|
|
|
|
/// let mut module = Module::new();
|
2020-05-30 04:28:17 +02:00
|
|
|
/// let hash = module.set_fn_4_mut("calc", |x: &mut i64, y: ImmutableString, z: i64, _w: ()| {
|
2020-05-28 08:07:34 +02:00
|
|
|
/// *x += y.len() as i64 + z; Ok(*x)
|
|
|
|
/// });
|
2020-07-27 12:10:45 +02:00
|
|
|
/// assert!(module.contains_fn(hash, true));
|
2020-05-28 08:07:34 +02:00
|
|
|
/// ```
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-05-28 08:07:34 +02:00
|
|
|
pub fn set_fn_4_mut<
|
|
|
|
A: Variant + Clone,
|
|
|
|
B: Variant + Clone,
|
|
|
|
C: Variant + Clone,
|
|
|
|
D: Variant + Clone,
|
|
|
|
T: Variant + Clone,
|
|
|
|
>(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
2020-06-08 08:10:16 +02:00
|
|
|
func: impl Fn(&mut A, B, C, D) -> FuncReturn<T> + SendSync + 'static,
|
2020-05-28 08:07:34 +02:00
|
|
|
) -> u64 {
|
2020-07-06 06:04:02 +02:00
|
|
|
let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| {
|
2020-09-19 12:12:23 +02:00
|
|
|
let b = cast_arg::<B>(&mut args[1]);
|
|
|
|
let c = cast_arg::<C>(&mut args[2]);
|
|
|
|
let d = cast_arg::<D>(&mut args[3]);
|
2020-08-11 07:46:09 +02:00
|
|
|
let a = &mut args[0].write_lock::<A>().unwrap();
|
2020-05-28 08:07:34 +02:00
|
|
|
|
2020-08-11 07:46:09 +02:00
|
|
|
func(a, b, c, d).map(Dynamic::from)
|
2020-05-28 08:07:34 +02:00
|
|
|
};
|
2020-07-07 16:59:23 +02:00
|
|
|
let arg_types = [
|
2020-05-28 08:07:34 +02:00
|
|
|
TypeId::of::<A>(),
|
|
|
|
TypeId::of::<B>(),
|
|
|
|
TypeId::of::<C>(),
|
2020-09-15 05:03:46 +02:00
|
|
|
TypeId::of::<D>(),
|
2020-05-28 08:07:34 +02:00
|
|
|
];
|
2020-09-25 12:07:39 +02:00
|
|
|
self.set_fn(
|
|
|
|
name,
|
2020-10-01 17:31:27 +02:00
|
|
|
FnAccess::Public,
|
2020-09-25 12:07:39 +02:00
|
|
|
&arg_types,
|
|
|
|
CallableFunction::from_method(Box::new(f)),
|
|
|
|
)
|
2020-05-28 08:07:34 +02:00
|
|
|
}
|
|
|
|
|
2020-05-05 11:51:40 +02:00
|
|
|
/// Get a Rust function.
|
|
|
|
///
|
|
|
|
/// The `u64` hash is calculated by the function `crate::calc_fn_hash`.
|
|
|
|
/// It is also returned by the `set_fn_XXX` calls.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-09-25 12:07:39 +02:00
|
|
|
pub(crate) fn get_fn(&self, hash_fn: u64, public_only: bool) -> Option<&CallableFunction> {
|
2020-09-11 16:32:59 +02:00
|
|
|
if hash_fn == 0 {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
self.functions
|
|
|
|
.get(&hash_fn)
|
2020-09-24 16:50:28 +02:00
|
|
|
.and_then(|(_, access, _, _, f)| match access {
|
2020-09-11 16:32:59 +02:00
|
|
|
_ if !public_only => Some(f),
|
|
|
|
FnAccess::Public => Some(f),
|
|
|
|
FnAccess::Private => None,
|
|
|
|
})
|
|
|
|
}
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get a modules-qualified function.
|
2020-06-28 09:49:24 +02:00
|
|
|
/// Name and Position in `EvalAltResult` are None and must be set afterwards.
|
2020-05-05 11:51:40 +02:00
|
|
|
///
|
2020-05-28 08:07:34 +02:00
|
|
|
/// The `u64` hash is calculated by the function `crate::calc_fn_hash` and must match
|
|
|
|
/// the hash calculated by `index_all_sub_modules`.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-09-25 12:07:39 +02:00
|
|
|
pub(crate) fn get_qualified_fn(&self, hash_qualified_fn: u64) -> Option<&CallableFunction> {
|
2020-07-27 06:52:32 +02:00
|
|
|
self.all_functions.get(&hash_qualified_fn)
|
2020-05-05 11:51:40 +02:00
|
|
|
}
|
2020-05-05 17:57:25 +02:00
|
|
|
|
2020-08-14 18:04:10 +02:00
|
|
|
/// Combine another module into this module.
|
|
|
|
/// The other module is consumed to merge into this module.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-08-14 18:04:10 +02:00
|
|
|
pub fn combine(&mut self, other: Self) -> &mut Self {
|
2020-09-30 03:57:21 +02:00
|
|
|
if !other.modules.is_empty() {
|
|
|
|
self.modules.extend(other.modules.into_iter());
|
|
|
|
}
|
|
|
|
if !other.variables.is_empty() {
|
|
|
|
self.variables.extend(other.variables.into_iter());
|
|
|
|
}
|
|
|
|
if !other.functions.is_empty() {
|
|
|
|
self.functions.extend(other.functions.into_iter());
|
|
|
|
}
|
|
|
|
if !other.type_iterators.is_empty() {
|
|
|
|
self.type_iterators.extend(other.type_iterators.into_iter());
|
|
|
|
}
|
2020-08-21 15:48:45 +02:00
|
|
|
self.all_functions.clear();
|
|
|
|
self.all_variables.clear();
|
|
|
|
self.indexed = false;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Combine another module into this module.
|
|
|
|
/// The other module is consumed to merge into this module.
|
|
|
|
/// Sub-modules are flattened onto the root module, with higher level overriding lower level.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-08-21 15:48:45 +02:00
|
|
|
pub fn combine_flatten(&mut self, other: Self) -> &mut Self {
|
2020-09-30 03:57:21 +02:00
|
|
|
if !other.modules.is_empty() {
|
|
|
|
other.modules.into_iter().for_each(|(_, m)| {
|
|
|
|
self.combine_flatten(m);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if !other.variables.is_empty() {
|
|
|
|
self.variables.extend(other.variables.into_iter());
|
|
|
|
}
|
|
|
|
if !other.functions.is_empty() {
|
|
|
|
self.functions.extend(other.functions.into_iter());
|
|
|
|
}
|
|
|
|
if !other.type_iterators.is_empty() {
|
|
|
|
self.type_iterators.extend(other.type_iterators.into_iter());
|
|
|
|
}
|
2020-08-14 18:04:10 +02:00
|
|
|
self.all_functions.clear();
|
|
|
|
self.all_variables.clear();
|
|
|
|
self.indexed = false;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2020-06-05 09:14:42 +02:00
|
|
|
/// Merge another module into this module.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-07-12 05:46:53 +02:00
|
|
|
pub fn merge(&mut self, other: &Self) -> &mut Self {
|
2020-09-24 16:50:28 +02:00
|
|
|
self.merge_filtered(other, &mut |_, _, _| true)
|
2020-06-30 12:34:58 +02:00
|
|
|
}
|
|
|
|
|
2020-07-26 09:53:22 +02:00
|
|
|
/// Merge another module into this module, with only selected script-defined functions based on a filter predicate.
|
2020-06-30 12:34:58 +02:00
|
|
|
pub(crate) fn merge_filtered(
|
|
|
|
&mut self,
|
|
|
|
other: &Self,
|
2020-09-24 16:50:28 +02:00
|
|
|
mut _filter: &mut impl FnMut(FnAccess, &str, usize) -> bool,
|
2020-07-12 05:46:53 +02:00
|
|
|
) -> &mut Self {
|
2020-08-21 15:48:45 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-09-30 03:57:21 +02:00
|
|
|
if !other.modules.is_empty() {
|
2020-10-01 17:31:27 +02:00
|
|
|
other.modules.iter().for_each(|(k, v)| {
|
2020-09-30 03:57:21 +02:00
|
|
|
let mut m = Self::new();
|
|
|
|
m.merge_filtered(v, _filter);
|
|
|
|
self.modules.insert(k.clone(), m);
|
2020-10-01 17:31:27 +02:00
|
|
|
});
|
2020-08-21 15:48:45 +02:00
|
|
|
}
|
|
|
|
#[cfg(feature = "no_function")]
|
2020-09-30 03:57:21 +02:00
|
|
|
if !other.modules.is_empty() {
|
|
|
|
self.modules
|
|
|
|
.extend(other.modules.iter().map(|(k, v)| (k.clone(), v.clone())));
|
|
|
|
}
|
|
|
|
if !other.variables.is_empty() {
|
|
|
|
self.variables
|
|
|
|
.extend(other.variables.iter().map(|(k, v)| (k.clone(), v.clone())));
|
|
|
|
}
|
|
|
|
if !other.functions.is_empty() {
|
|
|
|
self.functions.extend(
|
|
|
|
other
|
|
|
|
.functions
|
|
|
|
.iter()
|
|
|
|
.filter(|(_, (_, _, _, _, v))| match v {
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
CallableFunction::Script(f) => {
|
|
|
|
_filter(f.access, f.name.as_str(), f.params.len())
|
|
|
|
}
|
|
|
|
_ => true,
|
|
|
|
})
|
|
|
|
.map(|(&k, v)| (k, v.clone())),
|
|
|
|
);
|
|
|
|
}
|
2020-06-30 12:34:58 +02:00
|
|
|
|
2020-09-30 03:57:21 +02:00
|
|
|
if !other.type_iterators.is_empty() {
|
|
|
|
self.type_iterators
|
|
|
|
.extend(other.type_iterators.iter().map(|(&k, v)| (k, v.clone())));
|
|
|
|
}
|
2020-06-30 12:34:58 +02:00
|
|
|
self.all_functions.clear();
|
|
|
|
self.all_variables.clear();
|
|
|
|
self.indexed = false;
|
2020-07-12 05:46:53 +02:00
|
|
|
self
|
2020-06-30 12:34:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Filter out the functions, retaining only some based on a filter predicate.
|
2020-07-04 10:21:15 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2020-07-12 05:46:53 +02:00
|
|
|
pub(crate) fn retain_functions(
|
|
|
|
&mut self,
|
2020-09-24 16:50:28 +02:00
|
|
|
mut filter: impl FnMut(FnAccess, &str, usize) -> bool,
|
2020-07-12 05:46:53 +02:00
|
|
|
) -> &mut Self {
|
2020-09-24 16:50:28 +02:00
|
|
|
self.functions.retain(|_, (_, _, _, _, v)| match v {
|
2020-09-25 12:07:39 +02:00
|
|
|
CallableFunction::Script(f) => filter(f.access, f.name.as_str(), f.params.len()),
|
2020-07-02 15:46:08 +02:00
|
|
|
_ => true,
|
2020-06-30 12:34:58 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
self.all_functions.clear();
|
|
|
|
self.all_variables.clear();
|
|
|
|
self.indexed = false;
|
2020-07-12 05:46:53 +02:00
|
|
|
self
|
2020-06-05 09:14:42 +02:00
|
|
|
}
|
|
|
|
|
2020-10-05 15:52:39 +02:00
|
|
|
/// Get the number of variables, functions and type iterators in the module.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-10-05 15:52:39 +02:00
|
|
|
pub fn count(&self) -> (usize, usize, usize) {
|
|
|
|
(
|
|
|
|
self.variables.len(),
|
|
|
|
self.variables.len(),
|
|
|
|
self.variables.len(),
|
|
|
|
)
|
2020-06-05 09:14:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get an iterator to the variables in the module.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-06-05 09:14:42 +02:00
|
|
|
pub fn iter_var(&self) -> impl Iterator<Item = (&String, &Dynamic)> {
|
|
|
|
self.variables.iter()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get an iterator to the functions in the module.
|
2020-10-09 05:15:25 +02:00
|
|
|
#[cfg(not(feature = "no_optimize"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-09-25 12:07:39 +02:00
|
|
|
pub(crate) fn iter_fn(&self) -> impl Iterator<Item = &FuncInfo> {
|
2020-06-05 09:14:42 +02:00
|
|
|
self.functions.values()
|
|
|
|
}
|
|
|
|
|
2020-06-26 16:33:27 +02:00
|
|
|
/// Get an iterator over all script-defined functions in the module.
|
2020-10-05 15:52:39 +02:00
|
|
|
///
|
|
|
|
/// Function metadata includes:
|
|
|
|
/// 1) Access mode (`FnAccess::Public` or `FnAccess::Private`).
|
|
|
|
/// 2) Function name (as string slice).
|
|
|
|
/// 3) Number of parameters.
|
|
|
|
/// 4) Shared reference to function definition `ScriptFnDef`.
|
2020-07-04 10:21:15 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-10-05 15:52:39 +02:00
|
|
|
pub(crate) fn iter_script_fn<'a>(
|
2020-10-02 17:14:33 +02:00
|
|
|
&'a self,
|
|
|
|
) -> impl Iterator<Item = (FnAccess, &str, usize, Shared<ScriptFnDef>)> + 'a {
|
2020-06-26 16:33:27 +02:00
|
|
|
self.functions
|
|
|
|
.values()
|
2020-09-24 16:50:28 +02:00
|
|
|
.map(|(_, _, _, _, f)| f)
|
2020-06-26 16:33:27 +02:00
|
|
|
.filter(|f| f.is_script())
|
2020-10-02 17:14:33 +02:00
|
|
|
.map(CallableFunction::get_shared_fn_def)
|
|
|
|
.map(|f| {
|
|
|
|
let func = f.clone();
|
|
|
|
(f.access, f.name.as_str(), f.params.len(), func)
|
2020-10-01 17:31:27 +02:00
|
|
|
})
|
2020-09-24 10:10:25 +02:00
|
|
|
}
|
|
|
|
|
2020-10-05 15:52:39 +02:00
|
|
|
/// Get an iterator over all script-defined functions in the module.
|
|
|
|
///
|
|
|
|
/// Function metadata includes:
|
|
|
|
/// 1) Access mode (`FnAccess::Public` or `FnAccess::Private`).
|
|
|
|
/// 2) Function name (as string slice).
|
|
|
|
/// 3) Number of parameters.
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
#[cfg(not(feature = "internals"))]
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-10-05 15:52:39 +02:00
|
|
|
pub fn iter_script_fn_info(&self) -> impl Iterator<Item = (FnAccess, &str, usize)> {
|
|
|
|
self.functions
|
|
|
|
.values()
|
|
|
|
.filter(|(_, _, _, _, f)| f.is_script())
|
|
|
|
.map(|(name, access, num_params, _, _)| (*access, name.as_str(), *num_params))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get an iterator over all script-defined functions in the module.
|
|
|
|
///
|
|
|
|
/// Function metadata includes:
|
|
|
|
/// 1) Access mode (`FnAccess::Public` or `FnAccess::Private`).
|
|
|
|
/// 2) Function name (as string slice).
|
|
|
|
/// 3) Number of parameters.
|
|
|
|
/// 4) _[INTERNALS]_ Shared reference to function definition `ScriptFnDef`.
|
|
|
|
/// Exported under the internals feature only.
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
#[cfg(feature = "internals")]
|
|
|
|
#[inline(always)]
|
|
|
|
pub fn iter_script_fn_info(
|
|
|
|
&self,
|
|
|
|
) -> impl Iterator<Item = (FnAccess, &str, usize, Shared<ScriptFnDef>)> {
|
|
|
|
self.iter_script_fn()
|
|
|
|
}
|
|
|
|
|
2020-07-06 06:04:02 +02:00
|
|
|
/// Create a new `Module` by evaluating an `AST`.
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
2020-10-03 05:42:54 +02:00
|
|
|
/// The entire `AST` is encapsulated into each function, allowing functions
|
|
|
|
/// to cross-call each other. Functions in the global namespace, plus all functions
|
|
|
|
/// defined in the module, are _merged_ into a _unified_ namespace before each call.
|
|
|
|
/// Therefore, all functions will be found.
|
2020-09-25 12:07:39 +02:00
|
|
|
///
|
2020-05-06 13:45:17 +02:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # fn main() -> Result<(), Box<rhai::EvalAltResult>> {
|
2020-05-08 16:38:56 +02:00
|
|
|
/// use rhai::{Engine, Module, Scope};
|
2020-05-06 13:45:17 +02:00
|
|
|
///
|
|
|
|
/// let engine = Engine::new();
|
2020-05-08 16:38:56 +02:00
|
|
|
/// let ast = engine.compile("let answer = 42; export answer;")?;
|
2020-10-03 05:42:54 +02:00
|
|
|
/// let module = Module::eval_ast_as_new(Scope::new(), &ast, &engine)?;
|
2020-05-06 13:45:17 +02:00
|
|
|
/// assert!(module.contains_var("answer"));
|
|
|
|
/// assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);
|
|
|
|
/// # Ok(())
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2020-05-13 13:21:42 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2020-10-03 05:42:54 +02:00
|
|
|
pub fn eval_ast_as_new(mut scope: Scope, ast: &AST, engine: &Engine) -> FuncReturn<Self> {
|
2020-06-27 17:56:24 +02:00
|
|
|
let mut mods = Imports::new();
|
|
|
|
|
2020-05-06 13:45:17 +02:00
|
|
|
// Run the script
|
2020-06-27 17:56:24 +02:00
|
|
|
engine.eval_ast_with_scope_raw(&mut scope, &mut mods, &ast)?;
|
2020-05-06 13:45:17 +02:00
|
|
|
|
|
|
|
// Create new module
|
|
|
|
let mut module = Module::new();
|
|
|
|
|
2020-06-27 17:56:24 +02:00
|
|
|
scope
|
|
|
|
.into_iter()
|
|
|
|
.for_each(|ScopeEntry { value, alias, .. }| {
|
|
|
|
// Variables with an alias left in the scope become module variables
|
2020-10-03 10:25:58 +02:00
|
|
|
if let Some(alias) = alias {
|
|
|
|
module.variables.insert(*alias, value);
|
2020-05-06 13:45:17 +02:00
|
|
|
}
|
2020-06-27 17:56:24 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
// Modules left in the scope become sub-modules
|
|
|
|
mods.into_iter().for_each(|(alias, m)| {
|
|
|
|
module.modules.insert(alias.to_string(), m);
|
|
|
|
});
|
2020-05-06 13:45:17 +02:00
|
|
|
|
2020-09-25 12:07:39 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-10-03 05:42:54 +02:00
|
|
|
{
|
2020-10-02 10:21:18 +02:00
|
|
|
let ast_lib: Shared<Module> = ast.lib().clone().into();
|
|
|
|
|
2020-10-01 17:31:27 +02:00
|
|
|
ast.iter_functions()
|
2020-10-02 17:14:33 +02:00
|
|
|
.filter(|(access, _, _, _)| access.is_public())
|
|
|
|
.for_each(|(_, name, num_params, func)| {
|
2020-10-02 10:21:18 +02:00
|
|
|
let ast_lib = ast_lib.clone();
|
2020-09-25 12:07:39 +02:00
|
|
|
|
|
|
|
module.set_raw_fn_as_scripted(
|
|
|
|
name,
|
2020-10-02 17:14:33 +02:00
|
|
|
num_params,
|
2020-09-28 05:01:25 +02:00
|
|
|
move |engine: &Engine, lib: &Module, args: &mut [&mut Dynamic]| {
|
2020-09-30 03:57:21 +02:00
|
|
|
let mut lib_merged;
|
|
|
|
|
|
|
|
let unified_lib = if lib.is_empty() {
|
|
|
|
// In the special case of the main script not defining any function
|
|
|
|
&ast_lib
|
|
|
|
} else {
|
|
|
|
lib_merged = lib.clone();
|
|
|
|
lib_merged.merge(&ast_lib);
|
|
|
|
&lib_merged
|
|
|
|
};
|
2020-09-28 05:01:25 +02:00
|
|
|
|
2020-09-25 14:24:03 +02:00
|
|
|
engine
|
2020-10-02 17:14:33 +02:00
|
|
|
.call_script_fn(
|
|
|
|
&mut Default::default(),
|
|
|
|
&mut Default::default(),
|
|
|
|
&mut Default::default(),
|
|
|
|
unified_lib,
|
2020-09-25 14:24:03 +02:00
|
|
|
&mut None,
|
2020-10-02 17:14:33 +02:00
|
|
|
&func.name,
|
|
|
|
func.as_ref(),
|
2020-09-25 14:24:03 +02:00
|
|
|
args,
|
2020-10-02 17:14:33 +02:00
|
|
|
0,
|
2020-09-25 14:24:03 +02:00
|
|
|
)
|
|
|
|
.map_err(|err| {
|
|
|
|
// Wrap the error in a module-error
|
|
|
|
Box::new(EvalAltResult::ErrorInModule(
|
|
|
|
"".to_string(),
|
|
|
|
err,
|
|
|
|
Position::none(),
|
|
|
|
))
|
|
|
|
})
|
2020-09-25 12:07:39 +02:00
|
|
|
},
|
|
|
|
);
|
2020-10-01 17:31:27 +02:00
|
|
|
});
|
2020-09-25 12:07:39 +02:00
|
|
|
}
|
2020-05-06 13:45:17 +02:00
|
|
|
|
|
|
|
Ok(module)
|
|
|
|
}
|
2020-05-07 18:19:08 +02:00
|
|
|
|
2020-06-05 09:14:42 +02:00
|
|
|
/// Scan through all the sub-modules in the module build an index of all
|
2020-05-07 18:19:08 +02:00
|
|
|
/// variables and external Rust functions via hashing.
|
2020-07-26 09:53:22 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2020-05-09 04:00:59 +02:00
|
|
|
pub(crate) fn index_all_sub_modules(&mut self) {
|
2020-05-07 18:19:08 +02:00
|
|
|
// Collect a particular module.
|
2020-05-09 04:00:59 +02:00
|
|
|
fn index_module<'a>(
|
2020-05-17 16:19:49 +02:00
|
|
|
module: &'a Module,
|
2020-05-09 04:00:59 +02:00
|
|
|
qualifiers: &mut Vec<&'a str>,
|
2020-05-07 18:19:08 +02:00
|
|
|
variables: &mut Vec<(u64, Dynamic)>,
|
2020-09-25 12:07:39 +02:00
|
|
|
functions: &mut Vec<(u64, CallableFunction)>,
|
2020-05-07 18:19:08 +02:00
|
|
|
) {
|
2020-10-01 17:31:27 +02:00
|
|
|
module.modules.iter().for_each(|(name, m)| {
|
2020-05-09 04:00:59 +02:00
|
|
|
// Index all the sub-modules first.
|
|
|
|
qualifiers.push(name);
|
2020-05-19 13:03:06 +02:00
|
|
|
index_module(m, qualifiers, variables, functions);
|
2020-05-09 04:00:59 +02:00
|
|
|
qualifiers.pop();
|
2020-10-01 17:31:27 +02:00
|
|
|
});
|
2020-05-07 18:19:08 +02:00
|
|
|
|
2020-05-09 04:00:59 +02:00
|
|
|
// Index all variables
|
2020-10-01 17:31:27 +02:00
|
|
|
module.variables.iter().for_each(|(var_name, value)| {
|
2020-05-09 04:00:59 +02:00
|
|
|
// Qualifiers + variable name
|
2020-05-19 14:07:51 +02:00
|
|
|
let hash_var = calc_fn_hash(qualifiers.iter().map(|&v| v), var_name, 0, empty());
|
2020-05-11 17:48:50 +02:00
|
|
|
variables.push((hash_var, value.clone()));
|
2020-10-01 17:31:27 +02:00
|
|
|
});
|
2020-05-09 04:00:59 +02:00
|
|
|
// Index all Rust functions
|
2020-10-01 17:31:27 +02:00
|
|
|
module
|
|
|
|
.functions
|
|
|
|
.iter()
|
|
|
|
.filter(|(_, (_, access, _, _, _))| access.is_public())
|
2020-10-02 17:14:33 +02:00
|
|
|
.for_each(|(&_hash, (name, _, _num_params, params, func))| {
|
2020-10-01 17:31:27 +02:00
|
|
|
if let Some(params) = params {
|
|
|
|
// Qualified Rust functions are indexed in two steps:
|
|
|
|
// 1) Calculate a hash in a similar manner to script-defined functions,
|
|
|
|
// i.e. qualifiers + function name + number of arguments.
|
|
|
|
let hash_qualified_script =
|
|
|
|
calc_fn_hash(qualifiers.iter().cloned(), name, params.len(), empty());
|
|
|
|
// 2) Calculate a second hash with no qualifiers, empty function name,
|
|
|
|
// zero number of arguments, and the actual list of argument `TypeId`'.s
|
|
|
|
let hash_fn_args = calc_fn_hash(empty(), "", 0, params.iter().cloned());
|
|
|
|
// 3) The final hash is the XOR of the two hashes.
|
|
|
|
let hash_qualified_fn = hash_qualified_script ^ hash_fn_args;
|
|
|
|
|
|
|
|
functions.push((hash_qualified_fn, func.clone()));
|
|
|
|
} else if cfg!(not(feature = "no_function")) {
|
|
|
|
let hash_qualified_script = if qualifiers.is_empty() {
|
|
|
|
_hash
|
|
|
|
} else {
|
|
|
|
// Qualifiers + function name + number of arguments.
|
2020-10-02 17:14:33 +02:00
|
|
|
calc_fn_hash(
|
|
|
|
qualifiers.iter().map(|&v| v),
|
|
|
|
&name,
|
|
|
|
*_num_params,
|
|
|
|
empty(),
|
|
|
|
)
|
2020-10-01 17:31:27 +02:00
|
|
|
};
|
|
|
|
functions.push((hash_qualified_script, func.clone()));
|
|
|
|
}
|
|
|
|
});
|
2020-06-27 17:56:24 +02:00
|
|
|
}
|
|
|
|
|
2020-10-01 17:31:27 +02:00
|
|
|
if !self.indexed {
|
|
|
|
let mut qualifiers: Vec<_> = Default::default();
|
|
|
|
let mut variables: Vec<_> = Default::default();
|
|
|
|
let mut functions: Vec<_> = Default::default();
|
2020-07-26 09:53:22 +02:00
|
|
|
|
2020-10-01 17:31:27 +02:00
|
|
|
qualifiers.push("root");
|
2020-05-19 13:03:06 +02:00
|
|
|
|
2020-10-01 17:31:27 +02:00
|
|
|
index_module(self, &mut qualifiers, &mut variables, &mut functions);
|
2020-05-07 18:19:08 +02:00
|
|
|
|
2020-10-01 17:31:27 +02:00
|
|
|
self.all_variables = variables.into_iter().collect();
|
|
|
|
self.all_functions = functions.into_iter().collect();
|
|
|
|
self.indexed = true;
|
|
|
|
}
|
2020-05-07 18:19:08 +02:00
|
|
|
}
|
2020-05-13 13:21:42 +02:00
|
|
|
|
|
|
|
/// Does a type iterator exist in the module?
|
2020-05-13 14:22:05 +02:00
|
|
|
pub fn contains_iter(&self, id: TypeId) -> bool {
|
2020-05-13 13:21:42 +02:00
|
|
|
self.type_iterators.contains_key(&id)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set a type iterator into the module.
|
2020-07-12 05:46:53 +02:00
|
|
|
pub fn set_iter(&mut self, typ: TypeId, func: IteratorFn) -> &mut Self {
|
2020-05-20 13:27:23 +02:00
|
|
|
self.type_iterators.insert(typ, func);
|
2020-06-27 17:56:24 +02:00
|
|
|
self.indexed = false;
|
2020-07-12 05:46:53 +02:00
|
|
|
self
|
2020-05-13 13:21:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get the specified type iterator.
|
2020-06-20 04:49:15 +02:00
|
|
|
pub(crate) fn get_iter(&self, id: TypeId) -> Option<IteratorFn> {
|
2020-05-20 13:27:23 +02:00
|
|
|
self.type_iterators.get(&id).cloned()
|
2020-05-13 13:21:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-03 12:49:11 +02:00
|
|
|
/// _[INTERNALS]_ A chain of module names to qualify a variable or function call.
|
2020-07-25 09:52:27 +02:00
|
|
|
/// Exported under the `internals` feature only.
|
|
|
|
///
|
|
|
|
/// A `u64` hash key is cached for quick search purposes.
|
2020-05-13 13:21:42 +02:00
|
|
|
///
|
|
|
|
/// A `StaticVec` is used because most module-level access contains only one level,
|
|
|
|
/// and it is wasteful to always allocate a `Vec` with one element.
|
2020-07-25 09:52:27 +02:00
|
|
|
///
|
|
|
|
/// ## WARNING
|
|
|
|
///
|
|
|
|
/// This type is volatile and may change.
|
2020-07-19 11:14:55 +02:00
|
|
|
#[derive(Clone, Eq, PartialEq, Default, Hash)]
|
2020-05-13 13:21:42 +02:00
|
|
|
pub struct ModuleRef(StaticVec<(String, Position)>, Option<NonZeroUsize>);
|
|
|
|
|
|
|
|
impl fmt::Debug for ModuleRef {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
fmt::Debug::fmt(&self.0, f)?;
|
|
|
|
|
|
|
|
if let Some(index) = self.1 {
|
|
|
|
write!(f, " -> {}", index)
|
|
|
|
} else {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Deref for ModuleRef {
|
|
|
|
type Target = StaticVec<(String, Position)>;
|
|
|
|
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
|
|
&self.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl DerefMut for ModuleRef {
|
|
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
|
&mut self.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for ModuleRef {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
for (m, _) in self.0.iter() {
|
|
|
|
write!(f, "{}{}", m, Token::DoubleColon.syntax())?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<StaticVec<(String, Position)>> for ModuleRef {
|
|
|
|
fn from(modules: StaticVec<(String, Position)>) -> Self {
|
|
|
|
Self(modules, None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-07 17:25:08 +02:00
|
|
|
impl<M: AsRef<Module>> Add<M> for &Module {
|
|
|
|
type Output = Module;
|
2020-10-07 09:40:36 +02:00
|
|
|
|
2020-10-07 17:25:08 +02:00
|
|
|
fn add(self, rhs: M) -> Self::Output {
|
2020-10-07 09:40:36 +02:00
|
|
|
let mut module = self.clone();
|
2020-10-07 17:25:08 +02:00
|
|
|
module.merge(rhs.as_ref());
|
2020-10-07 09:40:36 +02:00
|
|
|
module
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-07 17:25:08 +02:00
|
|
|
impl<M: AsRef<Module>> Add<M> for Module {
|
2020-10-07 09:40:36 +02:00
|
|
|
type Output = Self;
|
|
|
|
|
2020-10-07 17:25:08 +02:00
|
|
|
fn add(mut self, rhs: M) -> Self::Output {
|
|
|
|
self.merge(rhs.as_ref());
|
|
|
|
self
|
2020-10-07 09:40:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-07 17:25:08 +02:00
|
|
|
impl<M: Into<Module>> AddAssign<M> for Module {
|
|
|
|
fn add_assign(&mut self, rhs: M) {
|
|
|
|
self.combine(rhs.into());
|
2020-10-07 09:40:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-13 13:21:42 +02:00
|
|
|
impl ModuleRef {
|
|
|
|
pub(crate) fn index(&self) -> Option<NonZeroUsize> {
|
|
|
|
self.1
|
|
|
|
}
|
|
|
|
pub(crate) fn set_index(&mut self, index: Option<NonZeroUsize>) {
|
|
|
|
self.1 = index
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-25 04:59:21 +02:00
|
|
|
/// Re-export module resolver trait.
|
2020-05-13 13:21:42 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2020-09-25 04:59:21 +02:00
|
|
|
pub use resolvers::ModuleResolver;
|
2020-05-06 13:45:17 +02:00
|
|
|
|
2020-09-25 04:59:21 +02:00
|
|
|
/// Re-export module resolvers.
|
2020-07-07 17:44:23 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2020-09-25 04:59:21 +02:00
|
|
|
pub mod resolvers;
|