From 398edf66b3f8e86c154fb8b45dcb943f11fedd39 Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Mon, 13 Jul 2020 13:43:28 +0800 Subject: [PATCH 1/3] Delete benchmark.yml --- .github/workflows/benchmark.yml | 29 ----------------------------- 1 file changed, 29 deletions(-) delete mode 100644 .github/workflows/benchmark.yml diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml deleted file mode 100644 index df310705..00000000 --- a/.github/workflows/benchmark.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: Benchmark -on: - push: - branches: - - master - -jobs: - benchmark: - name: Run Rust benchmark - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - run: rustup toolchain update nightly && rustup default nightly - - name: Run benchmark - run: cargo +nightly bench | tee output.txt - - name: Store benchmark result - uses: rhysd/github-action-benchmark@v1 - with: - name: Rust Benchmark - tool: 'cargo' - output-file-path: output.txt - # Use personal access token instead of GITHUB_TOKEN due to https://github.community/t5/GitHub-Actions/Github-action-not-triggering-gh-pages-upon-push/td-p/26869/highlight/false - github-token: ${{ secrets.RHAI }} - auto-push: true - # Show alert with commit comment on detecting possible performance regression - alert-threshold: '200%' - comment-on-alert: true - fail-on-alert: true - alert-comment-cc-users: '@schungx' From 96aa5ed39e88bb5a79bdc1181212f3b8ca670bdc Mon Sep 17 00:00:00 2001 From: John-John Tedro Date: Fri, 24 Jul 2020 16:20:47 +0200 Subject: [PATCH 2/3] set_indexer_set_fn to support setting generic value --- src/module.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/module.rs b/src/module.rs index 7216c248..d4cec91e 100644 --- a/src/module.rs +++ b/src/module.rs @@ -738,18 +738,18 @@ impl Module { /// }); /// assert!(module.contains_fn(hash)); /// ``` - pub fn set_indexer_set_fn( + pub fn set_indexer_set_fn( &mut self, - func: impl Fn(&mut A, B, A) -> FuncReturn<()> + SendSync + 'static, + func: impl Fn(&mut A, B, C) -> FuncReturn<()> + SendSync + 'static, ) -> u64 { let f = move |_: &Engine, _: &Module, args: &mut FnCallArgs| { let b = mem::take(args[1]).cast::(); - let c = mem::take(args[2]).cast::(); + let c = mem::take(args[2]).cast::(); let a = args[0].downcast_mut::().unwrap(); func(a, b, c).map(Dynamic::from) }; - let arg_types = [TypeId::of::(), TypeId::of::(), TypeId::of::()]; + let arg_types = [TypeId::of::(), TypeId::of::(), TypeId::of::()]; self.set_fn( FN_IDX_SET, Public, From ea22591e365a55d40b00b0ccee24f029f4ef732d Mon Sep 17 00:00:00 2001 From: John-John Tedro Date: Fri, 24 Jul 2020 19:08:59 +0200 Subject: [PATCH 3/3] Support u128/i128 types during serialization --- src/serde/de.rs | 24 ++++++++++++++++++++++++ src/serde/ser.rs | 30 ++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/src/serde/de.rs b/src/serde/de.rs index 88533718..4ab9919a 100644 --- a/src/serde/de.rs +++ b/src/serde/de.rs @@ -162,10 +162,12 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> { Union::Variant(value) if value.is::() => self.deserialize_i16(visitor), Union::Variant(value) if value.is::() => self.deserialize_i32(visitor), Union::Variant(value) if value.is::() => self.deserialize_i64(visitor), + Union::Variant(value) if value.is::() => self.deserialize_i128(visitor), Union::Variant(value) if value.is::() => self.deserialize_u8(visitor), Union::Variant(value) if value.is::() => self.deserialize_u16(visitor), Union::Variant(value) if value.is::() => self.deserialize_u32(visitor), Union::Variant(value) if value.is::() => self.deserialize_u64(visitor), + Union::Variant(value) if value.is::() => self.deserialize_u128(visitor), Union::Variant(_) => self.type_error(), } @@ -219,6 +221,18 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> { } } + fn deserialize_i128>(self, visitor: V) -> Result> { + if let Ok(v) = self.value.as_int() { + self.deserialize_int(v, visitor) + } else if cfg!(not(feature = "only_i32")) { + self.type_error() + } else { + self.value + .downcast_ref::() + .map_or_else(|| self.type_error(), |&x| visitor.visit_i128(x)) + } + } + fn deserialize_u8>(self, visitor: V) -> Result> { if let Ok(v) = self.value.as_int() { self.deserialize_int(v, visitor) @@ -259,6 +273,16 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> { } } + fn deserialize_u128>(self, visitor: V) -> Result> { + if let Ok(v) = self.value.as_int() { + self.deserialize_int(v, visitor) + } else { + self.value + .downcast_ref::() + .map_or_else(|| self.type_error(), |&x| visitor.visit_u128(x)) + } + } + fn deserialize_f32>(self, visitor: V) -> Result> { #[cfg(not(feature = "no_float"))] return self diff --git a/src/serde/ser.rs b/src/serde/ser.rs index 181573b0..7c3f9321 100644 --- a/src/serde/ser.rs +++ b/src/serde/ser.rs @@ -150,6 +150,21 @@ impl Serializer for &mut DynamicSerializer { } } + fn serialize_i128(self, v: i128) -> Result> { + #[cfg(not(feature = "only_i32"))] + if v > i64::MAX as i128 { + return Ok(Dynamic::from(v)); + } else { + return self.serialize_i64(v as i64); + } + #[cfg(feature = "only_i32")] + if v > i32::MAX as i128 { + return Ok(Dynamic::from(v)); + } else { + return self.serialize_i32(v as i32); + } + } + fn serialize_u8(self, v: u8) -> Result> { #[cfg(not(feature = "only_i32"))] return self.serialize_i64(i64::from(v)); @@ -190,6 +205,21 @@ impl Serializer for &mut DynamicSerializer { } } + fn serialize_u128(self, v: u128) -> Result> { + #[cfg(not(feature = "only_i32"))] + if v > i64::MAX as u128 { + return Ok(Dynamic::from(v)); + } else { + return self.serialize_i64(v as i64); + } + #[cfg(feature = "only_i32")] + if v > i32::MAX as u128 { + return Ok(Dynamic::from(v)); + } else { + return self.serialize_i32(v as i32); + } + } + fn serialize_f32(self, v: f32) -> Result> { Ok(Dynamic::from(v)) }