2020-04-21 17:01:10 +02:00
|
|
|
//! This module contains all built-in _packages_ available to Rhai, plus facilities to define custom packages.
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
use crate::engine::{FnAny, IteratorFn};
|
|
|
|
|
2020-05-07 09:25:50 +02:00
|
|
|
use crate::stdlib::{any::TypeId, boxed::Box, collections::HashMap, rc::Rc, sync::Arc, vec::Vec};
|
2020-04-20 18:11:25 +02:00
|
|
|
|
|
|
|
mod arithmetic;
|
|
|
|
mod array_basic;
|
|
|
|
mod iter_basic;
|
|
|
|
mod logic;
|
|
|
|
mod map_basic;
|
|
|
|
mod math_basic;
|
|
|
|
mod pkg_core;
|
|
|
|
mod pkg_std;
|
|
|
|
mod string_basic;
|
|
|
|
mod string_more;
|
|
|
|
mod time_basic;
|
2020-04-21 17:01:10 +02:00
|
|
|
mod utils;
|
2020-04-20 18:11:25 +02:00
|
|
|
|
|
|
|
pub use arithmetic::ArithmeticPackage;
|
2020-04-21 17:25:12 +02:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-04-20 18:11:25 +02:00
|
|
|
pub use array_basic::BasicArrayPackage;
|
|
|
|
pub use iter_basic::BasicIteratorPackage;
|
|
|
|
pub use logic::LogicPackage;
|
2020-04-21 17:25:12 +02:00
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-04-20 18:11:25 +02:00
|
|
|
pub use map_basic::BasicMapPackage;
|
|
|
|
pub use math_basic::BasicMathPackage;
|
|
|
|
pub use pkg_core::CorePackage;
|
|
|
|
pub use pkg_std::StandardPackage;
|
|
|
|
pub use string_basic::BasicStringPackage;
|
|
|
|
pub use string_more::MoreStringPackage;
|
2020-04-24 06:39:24 +02:00
|
|
|
#[cfg(not(feature = "no_std"))]
|
2020-04-20 18:11:25 +02:00
|
|
|
pub use time_basic::BasicTimePackage;
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
pub use utils::*;
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Trait that all packages must implement.
|
|
|
|
pub trait Package {
|
|
|
|
/// Create a new instance of a package.
|
|
|
|
fn new() -> Self;
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Register all the functions in a package into a store.
|
|
|
|
fn init(lib: &mut PackageStore);
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Retrieve the generic package library from this package.
|
|
|
|
fn get(&self) -> PackageLibrary;
|
2020-04-20 18:11:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Type to store all functions in the package.
|
2020-05-05 09:00:10 +02:00
|
|
|
#[derive(Default)]
|
2020-04-21 17:01:10 +02:00
|
|
|
pub struct PackageStore {
|
|
|
|
/// All functions, keyed by a hash created from the function name and parameter types.
|
|
|
|
pub functions: HashMap<u64, Box<FnAny>>,
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// All iterator functions, keyed by the type producing the iterator.
|
|
|
|
pub type_iterators: HashMap<TypeId, Box<IteratorFn>>,
|
2020-04-20 18:11:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
impl PackageStore {
|
|
|
|
/// Create a new `PackageStore`.
|
|
|
|
pub fn new() -> Self {
|
2020-05-05 09:00:10 +02:00
|
|
|
Default::default()
|
2020-04-21 17:01:10 +02:00
|
|
|
}
|
2020-05-07 09:25:50 +02:00
|
|
|
/// Get an iterator over the keys of the functions in the `PackageStore`.
|
|
|
|
pub fn function_keys(&self) -> impl Iterator<Item = &u64> {
|
|
|
|
self.functions.keys()
|
|
|
|
}
|
|
|
|
/// Get an iterator over the `TypeId` of the type iterators in the `PackageStore`.
|
|
|
|
pub fn type_iterator_keys(&self) -> impl Iterator<Item = &TypeId> {
|
|
|
|
self.type_iterators.keys()
|
|
|
|
}
|
|
|
|
/// Does the specified function hash key exist in the `PackageStore`?
|
|
|
|
pub fn contains_function(&self, hash: u64) -> bool {
|
|
|
|
self.functions.contains_key(&hash)
|
|
|
|
}
|
|
|
|
/// Get specified function via its hash key.
|
|
|
|
pub fn get_function(&self, hash: u64) -> Option<&Box<FnAny>> {
|
|
|
|
self.functions.get(&hash)
|
|
|
|
}
|
|
|
|
/// Does the specified TypeId iterator exist in the `PackageStore`?
|
|
|
|
pub fn contains_iterator(&self, id: TypeId) -> bool {
|
|
|
|
self.type_iterators.contains_key(&id)
|
|
|
|
}
|
|
|
|
/// Get the specified TypeId iterator.
|
|
|
|
pub fn get_iterator(&self, id: TypeId) -> Option<&Box<IteratorFn>> {
|
|
|
|
self.type_iterators.get(&id)
|
|
|
|
}
|
2020-04-20 18:11:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Type which `Rc`-wraps a `PackageStore` to facilitate sharing library instances.
|
|
|
|
#[cfg(not(feature = "sync"))]
|
|
|
|
pub type PackageLibrary = Rc<PackageStore>;
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
/// Type which `Arc`-wraps a `PackageStore` to facilitate sharing library instances.
|
|
|
|
#[cfg(feature = "sync")]
|
|
|
|
pub type PackageLibrary = Arc<PackageStore>;
|
2020-05-07 09:25:50 +02:00
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
/// Type containing a collection of `PackageLibrary` instances.
|
|
|
|
/// All function and type iterator keys in the loaded packages are indexed for fast access.
|
|
|
|
pub(crate) struct PackagesCollection {
|
|
|
|
/// Collection of `PackageLibrary` instances.
|
|
|
|
packages: Vec<PackageLibrary>,
|
|
|
|
/// Index of all function keys, pointing to the offset in `packages`.
|
|
|
|
function_keys: HashMap<u64, usize>,
|
|
|
|
/// Index of all type iterator `TypeId`'s, pointing to the offset in `packages`.
|
|
|
|
iterator_types: HashMap<TypeId, usize>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PackagesCollection {
|
|
|
|
/// Add a `PackageLibrary` into the `PackagesCollection`.
|
|
|
|
pub fn push(&mut self, package: PackageLibrary) {
|
|
|
|
let index = self.packages.len();
|
|
|
|
package.function_keys().for_each(|&hash| {
|
|
|
|
self.function_keys.insert(hash, index);
|
|
|
|
});
|
|
|
|
package.type_iterator_keys().for_each(|&id| {
|
|
|
|
self.iterator_types.insert(id, index);
|
|
|
|
});
|
|
|
|
self.packages.push(package);
|
|
|
|
}
|
|
|
|
/// Does the specified function hash key exist in the `PackagesCollection`?
|
|
|
|
pub fn contains_function(&self, hash: u64) -> bool {
|
|
|
|
self.function_keys.contains_key(&hash)
|
|
|
|
}
|
|
|
|
/// Get specified function via its hash key.
|
|
|
|
pub fn get_function(&self, hash: u64) -> Option<&Box<FnAny>> {
|
|
|
|
self.function_keys
|
|
|
|
.get(&hash)
|
|
|
|
.and_then(|&index| self.packages[index].functions.get(&hash))
|
|
|
|
}
|
|
|
|
/// Does the specified TypeId iterator exist in the `PackagesCollection`?
|
|
|
|
pub fn contains_iterator(&self, id: TypeId) -> bool {
|
|
|
|
self.iterator_types.contains_key(&id)
|
|
|
|
}
|
|
|
|
/// Get the specified TypeId iterator.
|
|
|
|
pub fn get_iterator(&self, id: TypeId) -> Option<&Box<IteratorFn>> {
|
|
|
|
self.iterator_types
|
|
|
|
.get(&id)
|
|
|
|
.and_then(|&index| self.packages[index].type_iterators.get(&id))
|
|
|
|
}
|
|
|
|
}
|