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

179
src/packages/array_basic.rs
View File

@@ -1,14 +1,12 @@
use super::{
create_new_package, reg_binary, reg_binary_mut, reg_trinary_mut, reg_unary_mut, Package,
PackageLibrary, PackageLibraryStore,
};
use super::{reg_binary, reg_binary_mut, reg_trinary_mut, reg_unary_mut};
use crate::def_package;
use crate::any::{Dynamic, Variant};
use crate::engine::Array;
use crate::fn_register::{map_dynamic as map, map_identity as copy};
use crate::fn_register::{map_dynamic as map, map_identity as pass};
use crate::parser::INT;
use crate::stdlib::ops::Deref;
use crate::stdlib::any::TypeId;
// Register array utility functions
fn push<T: Variant + Clone>(list: &mut Array, item: T) {
@@ -31,16 +29,6 @@ fn pad<T: Variant + Clone>(list: &mut Array, len: INT, item: T) {
}
}
pub struct BasicArrayPackage(PackageLibrary);
impl Deref for BasicArrayPackage {
type Target = PackageLibrary;
fn deref(&self) -> &PackageLibrary {
&self.0
}
}
macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => {
$(reg_binary_mut($lib, $op, $func::<$par>, map);)* };
}
@@ -48,92 +36,87 @@ macro_rules! reg_tri { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => {
$(reg_trinary_mut($lib, $op, $func::<$par>, map);)* };
}
impl Package for BasicArrayPackage {
fn new() -> Self {
let mut pkg = create_new_package();
Self::init(&mut pkg);
Self(pkg.into())
#[cfg(not(feature = "no_index"))]
def_package!(BasicArrayPackage:"Basic array utilities.", lib, {
reg_op!(lib, "push", push, INT, bool, char, String, Array, ());
reg_tri!(lib, "pad", pad, INT, bool, char, String, Array, ());
reg_tri!(lib, "insert", ins, INT, bool, char, String, Array, ());
reg_binary_mut(lib, "append", |x: &mut Array, y: Array| x.extend(y), map);
reg_binary(
lib,
"+",
|mut x: Array, y: Array| {
x.extend(y);
x
},
map,
);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
reg_op!(lib, "push", push, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
reg_tri!(lib, "pad", pad, i8, u8, i16, u16, i32, u32, i64, u64, i128, u128);
reg_tri!(lib, "insert", ins, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
}
fn get(&self) -> PackageLibrary {
self.0.clone()
#[cfg(not(feature = "no_float"))]
{
reg_op!(lib, "push", push, f32, f64);
reg_tri!(lib, "pad", pad, f32, f64);
reg_tri!(lib, "insert", ins, f32, f64);
}
fn init(lib: &mut PackageLibraryStore) {
#[cfg(not(feature = "no_index"))]
{
reg_op!(lib, "push", push, INT, bool, char, String, Array, ());
reg_tri!(lib, "pad", pad, INT, bool, char, String, Array, ());
reg_tri!(lib, "insert", ins, INT, bool, char, String, Array, ());
reg_binary_mut(lib, "append", |x: &mut Array, y: Array| x.extend(y), map);
reg_binary(
lib,
"+",
|mut x: Array, y: Array| {
x.extend(y);
x
},
map,
);
#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
{
reg_op!(lib, "push", push, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
reg_tri!(lib, "pad", pad, i8, u8, i16, u16, i32, u32, i64, u64, i128, u128);
reg_tri!(lib, "insert", ins, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
reg_unary_mut(
lib,
"pop",
|list: &mut Array| list.pop().unwrap_or_else(|| Dynamic::from_unit()),
pass,
);
reg_unary_mut(
lib,
"shift",
|list: &mut Array| {
if !list.is_empty() {
Dynamic::from_unit()
} else {
list.remove(0)
}
#[cfg(not(feature = "no_float"))]
{
reg_op!(lib, "push", push, f32, f64);
reg_tri!(lib, "pad", pad, f32, f64);
reg_tri!(lib, "insert", ins, f32, f64);
},
pass,
);
reg_binary_mut(
lib,
"remove",
|list: &mut Array, len: INT| {
if len < 0 || (len as usize) >= list.len() {
Dynamic::from_unit()
} else {
list.remove(len as usize)
}
},
pass,
);
reg_unary_mut(lib, "len", |list: &mut Array| list.len() as INT, map);
reg_unary_mut(lib, "clear", |list: &mut Array| list.clear(), map);
reg_binary_mut(
lib,
"truncate",
|list: &mut Array, len: INT| {
if len >= 0 {
list.truncate(len as usize);
}
},
map,
);
reg_unary_mut(
lib,
"pop",
|list: &mut Array| list.pop().unwrap_or_else(|| Dynamic::from_unit()),
copy,
);
reg_unary_mut(
lib,
"shift",
|list: &mut Array| {
if !list.is_empty() {
Dynamic::from_unit()
} else {
list.remove(0)
}
},
copy,
);
reg_binary_mut(
lib,
"remove",
|list: &mut Array, len: INT| {
if len < 0 || (len as usize) >= list.len() {
Dynamic::from_unit()
} else {
list.remove(len as usize)
}
},
copy,
);
reg_unary_mut(lib, "len", |list: &mut Array| list.len() as INT, map);
reg_unary_mut(lib, "clear", |list: &mut Array| list.clear(), map);
reg_binary_mut(
lib,
"truncate",
|list: &mut Array, len: INT| {
if len >= 0 {
list.truncate(len as usize);
}
},
map,
);
}
}
}
// Register array iterator
lib.type_iterators.insert(
TypeId::of::<Array>(),
Box::new(|a: &Dynamic| {
Box::new(a.downcast_ref::<Array>().unwrap().clone().into_iter())
as Box<dyn Iterator<Item = Dynamic>>
}),
);
});