Struct casbin::rhai::Module

pub struct Module { /* fields omitted */ }

A module which may contain variables, sub-modules, external Rust functions, and/or script-defined functions.

Implementations

impl Module

pub fn new() -> Module

Create a new Module.

Example

use rhai::Module;

let mut module = Module::new();
module.set_var("answer", 42_i64);
assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);

pub fn id(&self) -> Option<&str>

Get the ID of the Module, if any.

Example

use rhai::Module;

let mut module = Module::new();
module.set_id(Some("hello"));
assert_eq!(module.id(), Some("hello"));

pub fn id_raw(&self) -> Option<&SmartString<Compact>>

Get the ID of the Module as an Identifier, if any.

Example

use rhai::Module;

let mut module = Module::new();
module.set_id(Some("hello"));
assert_eq!(module.id_raw().map(|s| s.as_str()), Some("hello"));

pub fn set_id<S>(&mut self, id: Option<S>) where
    S: Into<SmartString<Compact>>, 

Set the ID of the Module.

Example

use rhai::Module;

let mut module = Module::new();
module.set_id(Some("hello"));
assert_eq!(module.id(), Some("hello"));

pub fn is_empty(&self) -> bool

Is the Module empty?

Example

use rhai::Module;

let module = Module::new();
assert!(module.is_empty());

pub fn is_indexed(&self) -> bool

Is the Module indexed?

Example

use rhai::Module;

let mut module = Module::new();
assert!(!module.is_indexed());

module.build_index();
assert!(module.is_indexed());

pub fn contains_var(&self, name: &str) -> bool

Does a variable exist in the Module?

Example

use rhai::Module;

let mut module = Module::new();
module.set_var("answer", 42_i64);
assert!(module.contains_var("answer"));

pub fn get_var_value<T>(&self, name: &str) -> Option<T> where
    T: Variant + Clone, 

Get the value of a Module variable.

Example

use rhai::Module;

let mut module = Module::new();
module.set_var("answer", 42_i64);
assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);

pub fn get_var(&self, name: &str) -> Option<Dynamic>

Get a Module variable as a Dynamic.

Example

use rhai::Module;

let mut module = Module::new();
module.set_var("answer", 42_i64);
assert_eq!(module.get_var("answer").unwrap().cast::<i64>(), 42);

pub fn set_var(
    &mut self,
    name: impl Into<SmartString<Compact>>,
    value: impl Variant + Clone
) -> &mut Module

Set a variable into the Module.

If there is an existing variable of the same name, it is replaced.

Example

use rhai::Module;

let mut module = Module::new();
module.set_var("answer", 42_i64);
assert_eq!(module.get_var_value::<i64>("answer").unwrap(), 42);

pub fn contains_sub_module(&self, name: &str) -> bool

Does a sub-module exist in the Module?

Example

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"));

pub fn get_sub_module(&self, name: &str) -> Option<&Module>

Get a sub-module in the Module.

Example

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());

pub fn set_sub_module(
    &mut self,
    name: impl Into<SmartString<Compact>>,
    sub_module: impl Into<Arc<Module>>
) -> &mut Module

Set a sub-module into the Module.

If there is an existing sub-module of the same name, it is replaced.

Example

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());

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

use rhai::Module;

let mut module = Module::new();
let hash = module.set_native_fn("calc", || Ok(42_i64));
assert!(module.contains_fn(hash));

pub fn update_fn_namespace(
    &mut self,
    hash_fn: u64,
    namespace: FnNamespace
) -> &mut Module

Update the namespace of a registered function.

The u64 hash is returned by the set_native_fn call.

pub fn set_fn(
    &mut self,
    name: impl AsRef<str> + Into<SmartString<Compact>>,
    namespace: FnNamespace,
    access: FnAccess,
    _arg_names: Option<&[&str]>,
    arg_types: &[TypeId],
    func: CallableFunction
) -> u64

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.

WARNING - Low Level API

This function is very low level.

pub fn set_raw_fn<N, T, F>(
    &mut self,
    name: N,
    namespace: FnNamespace,
    access: FnAccess,
    arg_types: &[TypeId],
    func: F
) -> u64 where
    T: Variant + Clone,
    F: Fn(NativeCallContext<'_>, &mut [&mut Dynamic]) -> Result<T, Box<EvalAltResult, Global>> + SendSync + 'static,
    N: AsRef<str> + Into<SmartString<Compact>>, 

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.

Use this to register a built-in function which must reference settings on the scripting 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.

If there is a similar existing Rust function, it is replaced.

WARNING - Low Level API

This function is very low level.

Arguments

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.

The function is assumed to be a method, meaning that the first argument should not be consumed. All other arguments can be consumed.

To access a primary argument value (i.e. cloning is cheap), use: args[n].as_xxx().unwrap()

To access an argument 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 argument, use args.get_mut(0).unwrap()

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

Example

use rhai::{Module, FnNamespace, FnAccess};

let mut module = Module::new();
let hash = module.set_raw_fn("double_or_not", FnNamespace::Internal, FnAccess::Public,
                // Pass parameter types via a slice with TypeId's
                &[std::any::TypeId::of::<i64>(), std::any::TypeId::of::<bool>()],
                // Fixed closure signature
                |context, 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.
                    let mut x = args[0].write_lock::<i64>().unwrap();

                    let orig = *x;

                    if double {
                        *x *= 2;            // the first argument can be mutated
                    }

                    Ok(orig)                // return Result<T, Box<EvalAltResult>>
                });

assert!(module.contains_fn(hash));

pub fn set_native_fn<ARGS, N, T, F>(&mut self, name: N, func: F) -> u64 where
    T: Variant + Clone,
    F: RegisterNativeFunction<ARGS, Result<T, Box<EvalAltResult, Global>>>,
    N: AsRef<str> + Into<SmartString<Compact>>, 

Set a Rust function into the Module, returning a hash key.

If there is a similar existing Rust function, it is replaced.

Function Namespace

The default function namespace is FnNamespace::Internal. Use update_fn_namespace to change it.

Function Metadata

No metadata for the function is registered. Use [update_fn_metadata][Module::update_fn_metadata] to add metadata.

Example

use rhai::Module;

let mut module = Module::new();
let hash = module.set_native_fn("calc", || Ok(42_i64));
assert!(module.contains_fn(hash));

pub fn set_getter_fn<ARGS, A, T, F>(&mut self, name: &str, func: F) -> u64 where
    T: Variant + Clone,
    A: Variant + Clone,
    F: RegisterNativeFunction<ARGS, Result<T, Box<EvalAltResult, Global>>> + Fn(&mut A) -> Result<T, Box<EvalAltResult, Global>> + SendSync + 'static, 

Set a Rust getter function taking one mutable parameter, returning a hash key. This function is automatically exposed to the global namespace.

If there is a similar existing Rust getter function, it is replaced.

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

Example

use rhai::Module;

let mut module = Module::new();
let hash = module.set_getter_fn("value", |x: &mut i64| { Ok(*x) });
assert!(module.contains_fn(hash));

pub fn set_setter_fn<ARGS, A, B, F>(&mut self, name: &str, func: F) -> u64 where
    A: Variant + Clone,
    B: Variant + Clone,
    F: RegisterNativeFunction<ARGS, Result<(), Box<EvalAltResult, Global>>> + Fn(&mut A, B) -> Result<(), Box<EvalAltResult, Global>> + SendSync + 'static, 

Set a Rust setter function taking two parameters (the first one mutable) into the Module, returning a hash key. This function is automatically exposed to the global namespace.

If there is a similar existing setter Rust function, it is replaced.

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

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));

pub fn set_indexer_get_fn<ARGS, A, B, T, F>(&mut self, func: F) -> u64 where
    T: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    F: RegisterNativeFunction<ARGS, Result<T, Box<EvalAltResult, Global>>> + Fn(&mut A, B) -> Result<T, Box<EvalAltResult, Global>> + SendSync + 'static, 

Set a Rust index getter taking two parameters (the first one mutable) into the Module, returning a hash key. This function is automatically exposed to the global namespace.

If there is a similar existing setter Rust function, it is replaced.

Panics

Panics if the type is Array or Map. Indexers for arrays, object maps and strings cannot be registered.

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

Example

use rhai::{Module, ImmutableString};

let mut module = Module::new();
let hash = module.set_indexer_get_fn(|x: &mut i64, y: ImmutableString| {
    Ok(*x + y.len() as i64)
});
assert!(module.contains_fn(hash));

pub fn set_indexer_set_fn<ARGS, A, B, C, F>(&mut self, func: F) -> u64 where
    C: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone,
    F: RegisterNativeFunction<ARGS, Result<(), Box<EvalAltResult, Global>>> + Fn(&mut A, B, C) -> Result<(), Box<EvalAltResult, Global>> + SendSync + 'static, 

Set a Rust index setter taking three parameters (the first one mutable) into the Module, returning a hash key. This function is automatically exposed to the global namespace.

If there is a similar existing Rust function, it is replaced.

Panics

Panics if the type is Array or Map. Indexers for arrays, object maps and strings cannot be registered.

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

Example

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(())
});
assert!(module.contains_fn(hash));

pub fn set_indexer_get_set_fn<A, B, T>(
    &mut self,
    get_fn: impl Fn(&mut A, B) -> Result<T, Box<EvalAltResult, Global>> + SendSync + 'static,
    set_fn: impl Fn(&mut A, B, T) -> Result<(), Box<EvalAltResult, Global>> + SendSync + 'static
) -> (u64, u64) where
    T: Variant + Clone,
    A: Variant + Clone,
    B: Variant + Clone, 

Set a pair of Rust index getter and setter functions, returning both hash keys. This is a short-hand for set_indexer_get_fn and set_indexer_set_fn.

If there are similar existing Rust functions, they are replaced.

Panics

Panics if the type is Array or Map. Indexers for arrays, object maps and strings cannot be registered.

Function Metadata

No metadata for the function is registered. Use update_fn_metadata to add metadata.

Example

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(())
    }
);
assert!(module.contains_fn(hash_get));
assert!(module.contains_fn(hash_set));

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.

pub fn combine(&mut self, other: Module) -> &mut Module

Combine another Module into this Module. The other Module is consumed to merge into this Module.

pub fn combine_flatten(&mut self, other: Module) -> &mut Module

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.

pub fn fill_with(&mut self, other: &Module) -> &mut Module

Polyfill this Module with another Module. Only items not existing in this Module are added.

pub fn merge(&mut self, other: &Module) -> &mut Module

Merge another Module into this Module.

pub fn count(&self) -> (usize, usize, usize)

Get the number of variables, functions and type iterators in the Module.

pub fn iter_sub_modules(&self) -> impl Iterator<Item = (&str, Arc<Module>)>

Get an iterator to the sub-modules in the Module.

pub fn iter_var(&self) -> impl Iterator<Item = (&str, &Dynamic)>

Get an iterator to the variables in the Module.

pub 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.

pub fn build_index(&mut self) -> &mut Module

Scan through all the sub-modules in the Module and build a hash index of all variables and functions as one flattened namespace.

If the Module is already indexed, this method has no effect.

pub fn contains_qualified_iter(&self, id: TypeId) -> bool

Does a type iterator exist in the entire module tree?

pub fn contains_iter(&self, id: TypeId) -> bool

Does a type iterator exist in the module?

pub fn set_iter(
    &mut self,
    typ: TypeId,
    func: fn(Dynamic) -> Box<dyn Iterator<Item = Dynamic> + 'static, Global>
) -> &mut Module

Set a type iterator into the Module.

pub fn set_iterable<T>(&mut self) -> &mut Module where
    T: Variant + Clone + IntoIterator,
    <T as IntoIterator>::Item: Variant,
    <T as IntoIterator>::Item: Clone, 

Set a type iterator into the Module.

pub fn set_iterator<T>(&mut self) -> &mut Module where
    T: Variant + Clone + Iterator,
    <T as Iterator>::Item: Variant,
    <T as Iterator>::Item: Clone, 

Set an iterator type into the Module as a type iterator.

Trait Implementations

impl<'_, M> Add<M> for &'_ Module where
    M: AsRef<Module>, 

type Output = Module

The resulting type after applying the + operator.

pub fn add(self, rhs: M) -> <&'_ Module as Add<M>>::Output

Performs the + operation.

impl<M> Add<M> for Module where
    M: AsRef<Module>, 

type Output = Module

The resulting type after applying the + operator.

pub fn add(self, rhs: M) -> <Module as Add<M>>::Output

Performs the + operation.

impl<M> AddAssign<M> for Module where
    M: Into<Module>, 

pub fn add_assign(&mut self, rhs: M)

Performs the += operation.

impl AsRef<Module> for Module

pub fn as_ref(&self) -> &Module

Performs the conversion.

impl AsRef<Module> for AST

pub fn as_ref(&self) -> &Module

Performs the conversion.

impl Clone for Module

pub fn clone(&self) -> Module

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl Default for Module

pub fn default() -> Module

Returns the “default value” for a type.