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

Add into_array and into_typed_array.

Browse Source
This commit is contained in:
Stephen Chung 2021-11-23 12:45:59 +08:00
parent 90200e607c
commit 6ad7b344bf
5 changed files with 192 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGELOG.md
View File

@ -1,6 +1,15 @@
Rhai Release Notes
==================
Version 1.3.0
=============
Enhancements
------------
* Added `into_array` and `into_typed_array` for `Dynamic`.
Version 1.2.0
=============

2
src/ast.rs
View File

@ -1862,7 +1862,7 @@ pub struct FnCallExpr {
/// Constant arguments are very common in function calls, and keeping each constant in
/// an [`Expr::DynamicConstant`] involves an additional allocation. Keeping the constant
/// values in an inlined array avoids these extra allocations.
pub constants: smallvec::SmallVec<[Dynamic; 2]>,
pub constants: StaticVec<Dynamic>,
/// Does this function call capture the parent scope?
pub capture_parent_scope: bool,
}

94
src/types/dynamic.rs
View File

@ -1798,7 +1798,7 @@ impl Dynamic {
_ => None,
}
}
/// Cast the [`Dynamic`] as a unit `()` and return it.
/// Cast the [`Dynamic`] as a unit `()`.
/// Returns the name of the actual type if the cast fails.
#[inline]
pub fn as_unit(&self) -> Result<(), &'static str> {
@ -1809,7 +1809,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Cast the [`Dynamic`] as the system integer type [`INT`] and return it.
/// Cast the [`Dynamic`] as the system integer type [`INT`].
/// Returns the name of the actual type if the cast fails.
#[inline]
pub fn as_int(&self) -> Result<INT, &'static str> {
@ -1820,7 +1820,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Cast the [`Dynamic`] as the system floating-point type [`FLOAT`] and return it.
/// Cast the [`Dynamic`] as the system floating-point type [`FLOAT`].
/// Returns the name of the actual type if the cast fails.
///
/// Not available under `no_float`.
@ -1834,7 +1834,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// _(decimal)_ Cast the [`Dynamic`] as a [`Decimal`](https://docs.rs/rust_decimal) and return it.
/// _(decimal)_ Cast the [`Dynamic`] as a [`Decimal`](https://docs.rs/rust_decimal).
/// Returns the name of the actual type if the cast fails.
///
/// Exported under the `decimal` feature only.
@ -1848,7 +1848,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Cast the [`Dynamic`] as a [`bool`] and return it.
/// Cast the [`Dynamic`] as a [`bool`].
/// Returns the name of the actual type if the cast fails.
#[inline]
pub fn as_bool(&self) -> Result<bool, &'static str> {
@ -1859,7 +1859,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Cast the [`Dynamic`] as a [`char`] and return it.
/// Cast the [`Dynamic`] as a [`char`].
/// Returns the name of the actual type if the cast fails.
#[inline]
pub fn as_char(&self) -> Result<char, &'static str> {
@ -1870,7 +1870,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Cast the [`Dynamic`] as an [`ImmutableString`] and return it as a string slice.
/// Cast the [`Dynamic`] as a string slice.
/// Returns the name of the actual type if the cast fails.
///
/// # Panics
@ -1885,7 +1885,7 @@ impl Dynamic {
_ => Err(self.type_name()),
}
}
/// Convert the [`Dynamic`] into a [`String`] and return it.
/// Convert the [`Dynamic`] into a [`String`].
/// If there are other references to the same string, a cloned copy is returned.
/// Returns the name of the actual type if the cast fails.
#[inline]
@ -1893,7 +1893,7 @@ impl Dynamic {
self.into_immutable_string()
.map(ImmutableString::into_owned)
}
/// Convert the [`Dynamic`] into an [`ImmutableString`] and return it.
/// Convert the [`Dynamic`] into an [`ImmutableString`].
/// Returns the name of the actual type if the cast fails.
#[inline]
pub fn into_immutable_string(self) -> Result<ImmutableString, &'static str> {
@ -2021,6 +2021,82 @@ impl<T: Variant + Clone> std::iter::FromIterator<T> for Dynamic {
))
}
}
#[cfg(not(feature = "no_index"))]
impl Dynamic {
/// Convert the [`Dynamic`] into an [`Array`].
/// Returns the name of the actual type if the cast fails.
#[inline(always)]
pub fn into_array(self) -> Result<Array, &'static str> {
match self.0 {
Union::Array(a, _, _) => Ok(*a),
#[cfg(not(feature = "no_closure"))]
Union::Shared(cell, _, _) => {
#[cfg(not(feature = "sync"))]
let value = cell.borrow();
#[cfg(feature = "sync")]
let value = cell.read().unwrap();
match value.0 {
Union::Array(ref a, _, _) => Ok(a.as_ref().clone()),
_ => Err((*value).type_name()),
}
}
_ => Err(self.type_name()),
}
}
/// Convert the [`Dynamic`] into a [`Vec`].
/// Returns the name of the actual type if any cast fails.
#[inline(always)]
pub fn into_typed_array<T: Variant + Clone>(self) -> Result<Vec<T>, &'static str> {
match self.0 {
Union::Array(a, _, _) => a
.into_iter()
.map(|v| {
#[cfg(not(feature = "no_closure"))]
let typ = if v.is_shared() {
// Avoid panics/deadlocks with shared values
"<shared>"
} else {
v.type_name()
};
#[cfg(feature = "no_closure")]
let typ = v.type_name();
v.try_cast::<T>().ok_or_else(|| typ)
})
.collect(),
#[cfg(not(feature = "no_closure"))]
Union::Shared(cell, _, _) => {
#[cfg(not(feature = "sync"))]
let value = cell.borrow();
#[cfg(feature = "sync")]
let value = cell.read().unwrap();
match value.0 {
Union::Array(ref a, _, _) => {
a.iter()
.map(|v| {
#[cfg(not(feature = "no_closure"))]
let typ = if v.is_shared() {
// Avoid panics/deadlocks with shared values
"<shared>"
} else {
v.type_name()
};
#[cfg(feature = "no_closure")]
let typ = v.type_name();
v.read_lock::<T>().ok_or_else(|| typ).map(|v| v.clone())
})
.collect()
}
_ => Err((*value).type_name()),
}
}
_ => Err(self.type_name()),
}
}
}
#[cfg(not(feature = "no_object"))]
impl Dynamic {
/// Create a [`Dynamic`] from a [`Map`].

26
src/types/scope.rs
View File

@ -10,13 +10,13 @@ use std::{borrow::Cow, iter::Extend};
/// Keep a number of entries inline (since [`Dynamic`] is usually small enough).
const SCOPE_ENTRIES_INLINED: usize = 8;
/// Type containing information about the current scope.
/// Useful for keeping state between [`Engine`][crate::Engine] evaluation runs.
/// Type containing information about the current scope. Useful for keeping state between
/// [`Engine`][crate::Engine] evaluation runs.
///
/// # Thread Safety
///
/// Currently, [`Scope`] is neither [`Send`] nor [`Sync`].
/// Turn on the `sync` feature to make it [`Send`] `+` [`Sync`].
/// Currently, [`Scope`] is neither [`Send`] nor [`Sync`]. Turn on the `sync` feature to make it
/// [`Send`] `+` [`Sync`].
///
/// # Example
///
@ -39,17 +39,19 @@ const SCOPE_ENTRIES_INLINED: usize = 8;
/// # }
/// ```
///
/// When searching for entries, newly-added entries are found before similarly-named but older entries,
/// allowing for automatic _shadowing_.
/// When searching for entries, newly-added entries are found before similarly-named but older
/// entries, allowing for automatic _shadowing_.
//
// # Implementation Notes
//
// [`Scope`] is implemented as two [`Vec`]'s of exactly the same length. Variables data (name, type, etc.)
// is manually split into two equal-length arrays. That's because variable names take up the most space,
// with [`Cow<str>`][Cow] being four words long, but in the vast majority of cases the name is NOT used to
// look up a variable. Variable lookup is usually via direct indexing, by-passing the name altogether.
// [`Scope`] is implemented as two [`Vec`]'s of exactly the same length. Variables data (name,
// type, etc.) is manually split into two equal-length arrays. That's because variable names take
// up the most space, with [`Cow<str>`][Cow] being four words long, but in the vast majority of
// cases the name is NOT used to look up a variable. Variable lookup is usually via direct
// indexing, by-passing the name altogether.
//
// Since [`Dynamic`] is reasonably small, packing it tightly improves cache locality when variables are accessed.
// Since [`Dynamic`] is reasonably small, packing it tightly improves cache locality when variables
// are accessed.
#[derive(Debug, Clone, Hash, Default)]
pub struct Scope<'a> {
/// Current value of the entry.
@ -493,7 +495,7 @@ impl<'a> Scope<'a> {
pub(crate) fn get_mut_by_index(&mut self, index: usize) -> &mut Dynamic {
self.values.get_mut(index).expect("valid index")
}
/// Update the access type of an entry in the [`Scope`].
/// Add an alias to an entry in the [`Scope`].
///
/// # Panics
///

72
tests/arrays.rs
View File

@ -1,9 +1,5 @@
#![cfg(not(feature = "no_index"))]
use rhai::{Array, Engine, EvalAltResult, INT};
fn convert_to_vec<T: Clone + 'static>(array: Array) -> Vec<T> {
array.into_iter().map(|v| v.clone_cast::<T>()).collect()
}
use rhai::{Array, Dynamic, Engine, EvalAltResult, INT};
#[test]
fn test_arrays() -> Result<(), Box<EvalAltResult>> {
@ -27,30 +23,42 @@ fn test_arrays() -> Result<(), Box<EvalAltResult>> {
assert!(engine.eval::<bool>("let y = [1, 2, 3]; 2 in y")?);
assert_eq!(engine.eval::<INT>("let y = [1, 2, 3]; y += 4; y[3]")?, 4);
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y[1] += 4; y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y[1] += 4; y")?
.into_typed_array::<INT>()?,
[1, 6, 3]
);
#[cfg(not(feature = "no_object"))]
{
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y.push(4); y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y.push(4); y")?
.into_typed_array::<INT>()?,
[1, 2, 3, 4]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y.insert(0, 4); y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y.insert(0, 4); y")?
.into_typed_array::<INT>()?,
[4, 1, 2, 3]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y.insert(999, 4); y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y.insert(999, 4); y")?
.into_typed_array::<INT>()?,
[1, 2, 3, 4]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y.insert(-2, 4); y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y.insert(-2, 4); y")?
.into_typed_array::<INT>()?,
[1, 4, 2, 3]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval("let y = [1, 2, 3]; y.insert(-999, 4); y")?),
engine
.eval::<Dynamic>("let y = [1, 2, 3]; y.insert(-999, 4); y")?
.into_typed_array::<INT>()?,
[4, 1, 2, 3]
);
assert_eq!(
@ -67,7 +75,8 @@ fn test_arrays() -> Result<(), Box<EvalAltResult>> {
);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [2, 9];
x.insert(-1, 1);
@ -81,29 +90,34 @@ fn test_arrays() -> Result<(), Box<EvalAltResult>> {
x
"
)?),
)?
.into_typed_array::<INT>()?,
[99, 2, 9, 3, 4, 5]
);
}
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
x += [4, 5];
x
"
)?),
)?
.into_typed_array::<INT>()?,
[1, 2, 3, 4, 5]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
let y = [4, 5];
x + y
"
)?),
)?
.into_typed_array::<INT>()?,
[1, 2, 3, 4, 5]
);
@ -172,42 +186,50 @@ fn test_arrays_map_reduce() -> Result<(), Box<EvalAltResult>> {
assert_eq!(engine.eval::<INT>("([1].map(|x| x + 41))[0]")?, 42);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
x.filter(|v| v > 2)
"
)?),
)?
.into_typed_array::<INT>()?,
[3]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
x.filter(|v, i| v > i)
"
)?),
)?
.into_typed_array::<INT>()?,
[1, 2, 3]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
x.map(|v| v * 2)
"
)?),
)?
.into_typed_array::<INT>()?,
[2, 4, 6]
);
assert_eq!(
convert_to_vec::<INT>(engine.eval(
engine
.eval::<Dynamic>(
"
let x = [1, 2, 3];
x.map(|v, i| v * i)
"
)?),
)?
.into_typed_array::<INT>()?,
[0, 2, 6]
);