kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Refine packages plumbing.

Browse Source
This commit is contained in:
Stephen Chung
2020-04-21 23:01:10 +08:00
parent e394824bf3
commit 0a75479637
19 changed files with 1232 additions and 1406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
src/packages/iter_basic.rs
View File

@@ -1,8 +1,6 @@
use super::{
create_new_package, reg_binary, reg_trinary, reg_unary_mut, Package, PackageLibrary,
PackageLibraryStore,
};
use super::{reg_binary, reg_trinary, reg_unary_mut, PackageStore};
use crate::def_package;
use crate::any::{Dynamic, Union, Variant};
use crate::engine::{Array, Map};
use crate::fn_register::map_dynamic as map;
@@ -10,15 +8,15 @@ use crate::parser::INT;
use crate::stdlib::{
any::TypeId,
ops::{Add, Deref, Range},
ops::{Add, Range},
};
// Register range function
fn reg_range<T: Variant + Clone>(lib: &mut PackageLibraryStore)
fn reg_range<T: Variant + Clone>(lib: &mut PackageStore)
where
Range<T>: Iterator<Item = T>,
{
lib.1.insert(
lib.type_iterators.insert(
TypeId::of::<Range<T>>(),
Box::new(|source: &Dynamic| {
Box::new(
@@ -57,13 +55,13 @@ where
}
}
fn reg_step<T>(lib: &mut PackageLibraryStore)
fn reg_step<T>(lib: &mut PackageStore)
where
for<'a> &'a T: Add<&'a T, Output = T>,
T: Variant + Clone + PartialOrd,
StepRange<T>: Iterator<Item = T>,
{
lib.1.insert(
lib.type_iterators.insert(
TypeId::of::<StepRange<T>>(),
Box::new(|source: &Dynamic| {
Box::new(
@@ -77,97 +75,44 @@ where
);
}
pub struct BasicIteratorPackage(PackageLibrary);
impl Deref for BasicIteratorPackage {
type Target = PackageLibrary;
fn deref(&self) -> &PackageLibrary {
&self.0
}
}
impl Package for BasicIteratorPackage {
fn new() -> Self {
let mut pkg = create_new_package();
Self::init(&mut pkg);
Self(pkg.into())
def_package!(BasicIteratorPackage:"Basic range iterators.", lib, {
fn get_range<T>(from: T, to: T) -> Range<T> {
from..to
}
fn get(&self) -> PackageLibrary {
self.0.clone()
reg_range::<INT>(lib);
reg_binary(lib, "range", get_range::<INT>, map);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
macro_rules! reg_range {
($self:expr, $x:expr, $( $y:ty ),*) => (
$(
reg_range::<$y>($self);
reg_binary($self, $x, get_range::<$y>, map);
)*
)
}
reg_range!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
}
fn init(lib: &mut PackageLibraryStore) {
#[cfg(not(feature = "no_index"))]
{
// Register array iterator
lib.1.insert(
TypeId::of::<Array>(),
Box::new(|a: &Dynamic| {
Box::new(a.downcast_ref::<Array>().unwrap().clone().into_iter())
as Box<dyn Iterator<Item = Dynamic>>
}),
);
reg_step::<INT>(lib);
reg_trinary(lib, "range", StepRange::<INT>, map);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
macro_rules! reg_step {
($self:expr, $x:expr, $( $y:ty ),*) => (
$(
reg_step::<$y>($self);
reg_trinary($self, $x, StepRange::<$y>, map);
)*
)
}
// Register map access functions
#[cfg(not(feature = "no_object"))]
{
fn map_get_keys(map: &mut Map) -> Vec<Dynamic> {
map.iter()
.map(|(k, _)| Dynamic(Union::Str(Box::new(k.to_string()))))
.collect::<Vec<_>>()
}
fn map_get_values(map: &mut Map) -> Vec<Dynamic> {
map.iter().map(|(_, v)| v.clone()).collect::<Vec<_>>()
}
#[cfg(not(feature = "no_index"))]
reg_unary_mut(lib, "keys", map_get_keys, map);
#[cfg(not(feature = "no_index"))]
reg_unary_mut(lib, "values", map_get_values, map);
}
fn get_range<T>(from: T, to: T) -> Range<T> {
from..to
}
reg_range::<INT>(lib);
reg_binary(lib, "range", get_range::<INT>, map);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
macro_rules! reg_range {
($self:expr, $x:expr, $( $y:ty ),*) => (
$(
reg_range::<$y>($self);
reg_binary($self, $x, get_range::<$y>, map);
)*
)
}
reg_range!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
}
reg_step::<INT>(lib);
reg_trinary(lib, "range", StepRange::<INT>, map);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
macro_rules! reg_step {
($self:expr, $x:expr, $( $y:ty ),*) => (
$(
reg_step::<$y>($self);
reg_trinary($self, $x, StepRange::<$y>, map);
)*
)
}
reg_step!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
}
reg_step!(lib, "range", i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
}
}
});