summaryrefslogtreecommitdiff
path: root/serde_v8
diff options
context:
space:
mode:
Diffstat (limited to 'serde_v8')
-rw-r--r--serde_v8/de.rs10
-rw-r--r--serde_v8/lib.rs3
-rw-r--r--serde_v8/magic/any_value.rs13
-rw-r--r--serde_v8/magic/buffer.rs114
-rw-r--r--serde_v8/magic/string_or_buffer.rs35
-rw-r--r--serde_v8/ser.rs24
-rw-r--r--serde_v8/serializable.rs10
-rw-r--r--serde_v8/tests/de.rs12
-rw-r--r--serde_v8/tests/magic.rs21
9 files changed, 93 insertions, 149 deletions
diff --git a/serde_v8/de.rs b/serde_v8/de.rs
index edb1263eb..d36cf6452 100644
--- a/serde_v8/de.rs
+++ b/serde_v8/de.rs
@@ -18,9 +18,9 @@ use crate::AnyValue;
use crate::BigInt;
use crate::ByteString;
use crate::DetachedBuffer;
+use crate::JsBuffer;
use crate::StringOrBuffer;
use crate::U16String;
-use crate::ZeroCopyBuf;
pub struct Deserializer<'a, 'b, 's> {
input: v8::Local<'a, v8::Value>,
@@ -337,8 +337,8 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
V: Visitor<'de>,
{
match name {
- ZeroCopyBuf::MAGIC_NAME => {
- visit_magic(visitor, ZeroCopyBuf::from_v8(self.scope, self.input)?)
+ JsBuffer::MAGIC_NAME => {
+ visit_magic(visitor, JsBuffer::from_v8(self.scope, self.input)?)
}
DetachedBuffer::MAGIC_NAME => {
visit_magic(visitor, DetachedBuffer::from_v8(self.scope, self.input)?)
@@ -452,7 +452,7 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
where
V: Visitor<'de>,
{
- magic::buffer::ZeroCopyBuf::from_v8(self.scope, self.input)
+ magic::buffer::JsBuffer::from_v8(self.scope, self.input)
.and_then(|zb| visitor.visit_bytes(&zb))
}
@@ -460,7 +460,7 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
where
V: Visitor<'de>,
{
- magic::buffer::ZeroCopyBuf::from_v8(self.scope, self.input)
+ magic::buffer::JsBuffer::from_v8(self.scope, self.input)
.and_then(|zb| visitor.visit_byte_buf(Vec::from(&*zb)))
}
}
diff --git a/serde_v8/lib.rs b/serde_v8/lib.rs
index 26d95c67a..59c8fd41f 100644
--- a/serde_v8/lib.rs
+++ b/serde_v8/lib.rs
@@ -17,7 +17,8 @@ pub use error::Result;
pub use keys::KeyCache;
pub use magic::any_value::AnyValue;
pub use magic::bigint::BigInt;
-pub use magic::buffer::ZeroCopyBuf;
+pub use magic::buffer::JsBuffer;
+pub use magic::buffer::ToJsBuffer;
pub use magic::bytestring::ByteString;
pub use magic::detached_buffer::DetachedBuffer;
pub use magic::string_or_buffer::StringOrBuffer;
diff --git a/serde_v8/magic/any_value.rs b/serde_v8/magic/any_value.rs
index 31a74cfde..9ae39bb2e 100644
--- a/serde_v8/magic/any_value.rs
+++ b/serde_v8/magic/any_value.rs
@@ -1,17 +1,19 @@
use num_bigint::BigInt;
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use super::buffer::ZeroCopyBuf;
+use super::buffer::JsBuffer;
use super::transl8::FromV8;
use super::transl8::ToV8;
use crate::magic::transl8::impl_magic;
use crate::Error;
+use crate::ToJsBuffer;
/// An untagged enum type that can be any of number, string, bool, bigint, or
/// buffer.
#[derive(Debug)]
pub enum AnyValue {
- Buffer(ZeroCopyBuf),
+ RustBuffer(ToJsBuffer),
+ V8Buffer(JsBuffer),
String(String),
Number(f64),
BigInt(BigInt),
@@ -26,7 +28,8 @@ impl ToV8 for AnyValue {
scope: &mut v8::HandleScope<'a>,
) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
match self {
- Self::Buffer(buf) => buf.to_v8(scope),
+ Self::RustBuffer(buf) => crate::to_v8(scope, buf),
+ Self::V8Buffer(_) => unreachable!(),
Self::String(s) => crate::to_v8(scope, s),
Self::Number(num) => crate::to_v8(scope, num),
Self::BigInt(bigint) => {
@@ -52,8 +55,8 @@ impl FromV8 for AnyValue {
let bigint = crate::BigInt::from_v8(scope, value)?;
Ok(AnyValue::BigInt(bigint.into()))
} else if value.is_array_buffer_view() {
- let buf = ZeroCopyBuf::from_v8(scope, value)?;
- Ok(AnyValue::Buffer(buf))
+ let buf = JsBuffer::from_v8(scope, value)?;
+ Ok(AnyValue::V8Buffer(buf))
} else if value.is_boolean() {
let string = crate::from_v8(scope, value)?;
Ok(AnyValue::Bool(string))
diff --git a/serde_v8/magic/buffer.rs b/serde_v8/magic/buffer.rs
index d0f0909bc..032a3be33 100644
--- a/serde_v8/magic/buffer.rs
+++ b/serde_v8/magic/buffer.rs
@@ -9,91 +9,93 @@ use super::transl8::ToV8;
use super::v8slice::V8Slice;
use crate::magic::transl8::impl_magic;
-// An asymmetric wrapper around V8Slice,
-// allowing us to use a single type for familiarity
-pub enum ZeroCopyBuf {
- FromV8(V8Slice),
- ToV8(Option<Box<[u8]>>),
-}
+pub struct JsBuffer(V8Slice);
-impl_magic!(ZeroCopyBuf);
+impl_magic!(JsBuffer);
-impl Debug for ZeroCopyBuf {
+impl Debug for JsBuffer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- f.debug_list().entries(self.as_ref().iter()).finish()
- }
-}
-
-impl ZeroCopyBuf {
- pub fn empty() -> Self {
- ZeroCopyBuf::ToV8(Some(vec![0_u8; 0].into_boxed_slice()))
+ f.debug_list().entries(self.0.as_ref().iter()).finish()
}
}
-impl Clone for ZeroCopyBuf {
+impl Clone for JsBuffer {
fn clone(&self) -> Self {
- match self {
- Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
- Self::ToV8(_) => panic!("Don't Clone a ZeroCopyBuf sent to v8"),
- }
+ Self(self.0.clone())
}
}
-impl AsRef<[u8]> for ZeroCopyBuf {
+impl AsRef<[u8]> for JsBuffer {
fn as_ref(&self) -> &[u8] {
- self
+ &self.0
}
}
-impl AsMut<[u8]> for ZeroCopyBuf {
+impl AsMut<[u8]> for JsBuffer {
fn as_mut(&mut self) -> &mut [u8] {
- &mut *self
+ &mut self.0
}
}
-impl Deref for ZeroCopyBuf {
+impl Deref for JsBuffer {
type Target = [u8];
fn deref(&self) -> &[u8] {
- match self {
- Self::FromV8(buf) => buf,
- Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
- }
+ &self.0
}
}
-impl DerefMut for ZeroCopyBuf {
+impl DerefMut for JsBuffer {
fn deref_mut(&mut self) -> &mut [u8] {
- match self {
- Self::FromV8(buf) => &mut *buf,
- Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
- }
+ &mut self.0
+ }
+}
+
+impl FromV8 for JsBuffer {
+ fn from_v8(
+ scope: &mut v8::HandleScope,
+ value: v8::Local<v8::Value>,
+ ) -> Result<Self, crate::Error> {
+ Ok(Self(V8Slice::from_v8(scope, value)?))
+ }
+}
+
+impl From<JsBuffer> for bytes::Bytes {
+ fn from(zbuf: JsBuffer) -> bytes::Bytes {
+ zbuf.0.into()
}
}
-impl From<Box<[u8]>> for ZeroCopyBuf {
+// NOTE(bartlomieju): we use Option here, because `to_v8()` uses `&mut self`
+// instead of `self` which is dictated by the `serde` API.
+#[derive(Debug)]
+pub struct ToJsBuffer(Option<Box<[u8]>>);
+
+impl_magic!(ToJsBuffer);
+
+impl ToJsBuffer {
+ pub fn empty() -> Self {
+ ToJsBuffer(Some(vec![0_u8; 0].into_boxed_slice()))
+ }
+}
+
+impl From<Box<[u8]>> for ToJsBuffer {
fn from(buf: Box<[u8]>) -> Self {
- ZeroCopyBuf::ToV8(Some(buf))
+ ToJsBuffer(Some(buf))
}
}
-impl From<Vec<u8>> for ZeroCopyBuf {
+impl From<Vec<u8>> for ToJsBuffer {
fn from(vec: Vec<u8>) -> Self {
vec.into_boxed_slice().into()
}
}
-impl ToV8 for ZeroCopyBuf {
+impl ToV8 for ToJsBuffer {
fn to_v8<'a>(
&mut self,
scope: &mut v8::HandleScope<'a>,
) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
- let buf: Box<[u8]> = match self {
- Self::FromV8(buf) => {
- let value: &[u8] = buf;
- value.into()
- }
- Self::ToV8(ref mut x) => x.take().expect("ZeroCopyBuf was empty"),
- };
+ let buf: Box<[u8]> = self.0.take().expect("RustToV8Buf was empty");
if buf.is_empty() {
let ab = v8::ArrayBuffer::new(scope, 0);
@@ -103,7 +105,7 @@ impl ToV8 for ZeroCopyBuf {
.into(),
);
}
- let buf_len = buf.len();
+ let buf_len: usize = buf.len();
let backing_store =
v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
let backing_store_shared = backing_store.make_shared();
@@ -115,23 +117,3 @@ impl ToV8 for ZeroCopyBuf {
)
}
}
-
-impl FromV8 for ZeroCopyBuf {
- fn from_v8(
- scope: &mut v8::HandleScope,
- value: v8::Local<v8::Value>,
- ) -> Result<Self, crate::Error> {
- Ok(Self::FromV8(V8Slice::from_v8(scope, value)?))
- }
-}
-
-impl From<ZeroCopyBuf> for bytes::Bytes {
- fn from(zbuf: ZeroCopyBuf) -> bytes::Bytes {
- match zbuf {
- ZeroCopyBuf::FromV8(v) => v.into(),
- ZeroCopyBuf::ToV8(mut v) => {
- v.take().expect("ZeroCopyBuf was empty").into()
- }
- }
- }
-}
diff --git a/serde_v8/magic/string_or_buffer.rs b/serde_v8/magic/string_or_buffer.rs
index 02571f669..986f7d32a 100644
--- a/serde_v8/magic/string_or_buffer.rs
+++ b/serde_v8/magic/string_or_buffer.rs
@@ -1,7 +1,6 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use super::buffer::ZeroCopyBuf;
+use super::buffer::JsBuffer;
use super::transl8::FromV8;
-use super::transl8::ToV8;
use crate::error::value_to_type_str;
use crate::magic::transl8::impl_magic;
use crate::Error;
@@ -9,7 +8,7 @@ use std::ops::Deref;
#[derive(Debug)]
pub enum StringOrBuffer {
- Buffer(ZeroCopyBuf),
+ Buffer(JsBuffer),
String(String),
}
@@ -35,40 +34,12 @@ impl<'a> TryFrom<&'a StringOrBuffer> for &'a str {
}
}
-impl ToV8 for StringOrBuffer {
- fn to_v8<'a>(
- &mut self,
- scope: &mut v8::HandleScope<'a>,
- ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
- match self {
- Self::Buffer(buf) => {
- let buf: Box<[u8]> = match buf {
- ZeroCopyBuf::FromV8(buf) => {
- let value: &[u8] = buf;
- value.into()
- }
- ZeroCopyBuf::ToV8(ref mut x) => {
- x.take().expect("ZeroCopyBuf was empty")
- }
- };
- let backing_store =
- v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
- Ok(
- v8::ArrayBuffer::with_backing_store(scope, &backing_store.into())
- .into(),
- )
- }
- Self::String(s) => crate::to_v8(scope, s),
- }
- }
-}
-
impl FromV8 for StringOrBuffer {
fn from_v8(
scope: &mut v8::HandleScope,
value: v8::Local<v8::Value>,
) -> Result<Self, crate::Error> {
- if let Ok(buf) = ZeroCopyBuf::from_v8(scope, value) {
+ if let Ok(buf) = JsBuffer::from_v8(scope, value) {
return Ok(Self::Buffer(buf));
} else if let Ok(s) = crate::from_v8(scope, value) {
return Ok(Self::String(s));
diff --git a/serde_v8/ser.rs b/serde_v8/ser.rs
index 74ad9ec10..51625f230 100644
--- a/serde_v8/ser.rs
+++ b/serde_v8/ser.rs
@@ -19,9 +19,8 @@ use crate::BigInt;
use crate::ByteString;
use crate::DetachedBuffer;
use crate::ExternalPointer;
-use crate::StringOrBuffer;
+use crate::ToJsBuffer;
use crate::U16String;
-use crate::ZeroCopyBuf;
type JsValue<'s> = v8::Local<'s, v8::Value>;
type JsResult<'s> = Result<JsValue<'s>>;
@@ -274,12 +273,11 @@ impl<'a, 'b, 'c, T: MagicType + ToV8> ser::SerializeStruct
pub enum StructSerializers<'a, 'b, 'c> {
ExternalPointer(MagicalSerializer<'a, 'b, 'c, magic::ExternalPointer>),
Magic(MagicalSerializer<'a, 'b, 'c, magic::Value<'a>>),
- ZeroCopyBuf(MagicalSerializer<'a, 'b, 'c, ZeroCopyBuf>),
+ RustToV8Buf(MagicalSerializer<'a, 'b, 'c, ToJsBuffer>),
MagicAnyValue(MagicalSerializer<'a, 'b, 'c, AnyValue>),
MagicDetached(MagicalSerializer<'a, 'b, 'c, DetachedBuffer>),
MagicByteString(MagicalSerializer<'a, 'b, 'c, ByteString>),
MagicU16String(MagicalSerializer<'a, 'b, 'c, U16String>),
- MagicStringOrBuffer(MagicalSerializer<'a, 'b, 'c, StringOrBuffer>),
MagicBigInt(MagicalSerializer<'a, 'b, 'c, BigInt>),
Regular(ObjectSerializer<'a, 'b, 'c>),
}
@@ -296,14 +294,11 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
match self {
StructSerializers::ExternalPointer(s) => s.serialize_field(key, value),
StructSerializers::Magic(s) => s.serialize_field(key, value),
- StructSerializers::ZeroCopyBuf(s) => s.serialize_field(key, value),
+ StructSerializers::RustToV8Buf(s) => s.serialize_field(key, value),
StructSerializers::MagicAnyValue(s) => s.serialize_field(key, value),
StructSerializers::MagicDetached(s) => s.serialize_field(key, value),
StructSerializers::MagicByteString(s) => s.serialize_field(key, value),
StructSerializers::MagicU16String(s) => s.serialize_field(key, value),
- StructSerializers::MagicStringOrBuffer(s) => {
- s.serialize_field(key, value)
- }
StructSerializers::MagicBigInt(s) => s.serialize_field(key, value),
StructSerializers::Regular(s) => s.serialize_field(key, value),
}
@@ -313,12 +308,11 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
match self {
StructSerializers::ExternalPointer(s) => s.end(),
StructSerializers::Magic(s) => s.end(),
- StructSerializers::ZeroCopyBuf(s) => s.end(),
+ StructSerializers::RustToV8Buf(s) => s.end(),
StructSerializers::MagicAnyValue(s) => s.end(),
StructSerializers::MagicDetached(s) => s.end(),
StructSerializers::MagicByteString(s) => s.end(),
StructSerializers::MagicU16String(s) => s.end(),
- StructSerializers::MagicStringOrBuffer(s) => s.end(),
StructSerializers::MagicBigInt(s) => s.end(),
StructSerializers::Regular(s) => s.end(),
}
@@ -588,9 +582,9 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
let m = MagicalSerializer::<U16String>::new(self.scope);
Ok(StructSerializers::MagicU16String(m))
}
- ZeroCopyBuf::MAGIC_NAME => {
- let m = MagicalSerializer::<ZeroCopyBuf>::new(self.scope);
- Ok(StructSerializers::ZeroCopyBuf(m))
+ ToJsBuffer::MAGIC_NAME => {
+ let m = MagicalSerializer::<ToJsBuffer>::new(self.scope);
+ Ok(StructSerializers::RustToV8Buf(m))
}
AnyValue::MAGIC_NAME => {
let m = MagicalSerializer::<AnyValue>::new(self.scope);
@@ -600,10 +594,6 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
let m = MagicalSerializer::<DetachedBuffer>::new(self.scope);
Ok(StructSerializers::MagicDetached(m))
}
- StringOrBuffer::MAGIC_NAME => {
- let m = MagicalSerializer::<StringOrBuffer>::new(self.scope);
- Ok(StructSerializers::MagicStringOrBuffer(m))
- }
BigInt::MAGIC_NAME => {
let m = MagicalSerializer::<BigInt>::new(self.scope);
Ok(StructSerializers::MagicBigInt(m))
diff --git a/serde_v8/serializable.rs b/serde_v8/serializable.rs
index b02aa0629..36a8bc27b 100644
--- a/serde_v8/serializable.rs
+++ b/serde_v8/serializable.rs
@@ -4,8 +4,8 @@ use std::mem::transmute_copy;
use crate::BigInt;
use crate::ByteString;
+use crate::ToJsBuffer;
use crate::U16String;
-use crate::ZeroCopyBuf;
/// Serializable exists to allow boxing values as "objects" to be serialized later,
/// this is particularly useful for async op-responses. This trait is a more efficient
@@ -63,7 +63,7 @@ pub enum Primitive {
Float32(f32),
Float64(f64),
String(String),
- ZeroCopyBuf(ZeroCopyBuf),
+ RustToV8Buf(ToJsBuffer),
ByteString(ByteString),
U16String(U16String),
BigInt(BigInt),
@@ -88,7 +88,7 @@ impl serde::Serialize for Primitive {
Self::Float32(x) => x.serialize(s),
Self::Float64(x) => x.serialize(s),
Self::String(x) => x.serialize(s),
- Self::ZeroCopyBuf(x) => x.serialize(s),
+ Self::RustToV8Buf(x) => x.serialize(s),
Self::ByteString(x) => x.serialize(s),
Self::U16String(x) => x.serialize(s),
Self::BigInt(x) => x.serialize(s),
@@ -134,8 +134,8 @@ impl<T: serde::Serialize + 'static> From<T> for SerializablePkg {
Self::Primitive(Primitive::Float64(tc(x)))
} else if tid == TypeId::of::<String>() {
Self::Primitive(Primitive::String(tc(x)))
- } else if tid == TypeId::of::<ZeroCopyBuf>() {
- Self::Primitive(Primitive::ZeroCopyBuf(tc(x)))
+ } else if tid == TypeId::of::<ToJsBuffer>() {
+ Self::Primitive(Primitive::RustToV8Buf(tc(x)))
} else if tid == TypeId::of::<ByteString>() {
Self::Primitive(Primitive::ByteString(tc(x)))
} else if tid == TypeId::of::<U16String>() {
diff --git a/serde_v8/tests/de.rs b/serde_v8/tests/de.rs
index 4c5cf7283..3abaa0979 100644
--- a/serde_v8/tests/de.rs
+++ b/serde_v8/tests/de.rs
@@ -7,8 +7,8 @@ use serde_v8::utils::v8_do;
use serde_v8::BigInt;
use serde_v8::ByteString;
use serde_v8::Error;
+use serde_v8::JsBuffer;
use serde_v8::U16String;
-use serde_v8::ZeroCopyBuf;
#[derive(Debug, Deserialize, PartialEq)]
struct MathOp {
@@ -248,31 +248,31 @@ fn de_string_or_buffer() {
fn de_buffers() {
// ArrayBufferView
dedo("new Uint8Array([97])", |scope, v| {
- let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+ let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
assert_eq!(&*buf, &[97]);
});
// ArrayBuffer
dedo("(new Uint8Array([97])).buffer", |scope, v| {
- let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+ let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
assert_eq!(&*buf, &[97]);
});
dedo(
"(Uint8Array.from([0x68, 0x65, 0x6C, 0x6C, 0x6F]))",
|scope, v| {
- let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+ let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
assert_eq!(&*buf, &[0x68, 0x65, 0x6C, 0x6C, 0x6F]);
},
);
dedo("(new ArrayBuffer(4))", |scope, v| {
- let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+ let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
assert_eq!(&*buf, &[0x0, 0x0, 0x0, 0x0]);
});
dedo("(new ArrayBuffer(8, { maxByteLength: 16}))", |scope, v| {
- let result: Result<ZeroCopyBuf, Error> = serde_v8::from_v8(scope, v);
+ let result: Result<JsBuffer, Error> = serde_v8::from_v8(scope, v);
matches!(result, Err(Error::ResizableBackingStoreNotSupported));
});
}
diff --git a/serde_v8/tests/magic.rs b/serde_v8/tests/magic.rs
index 8ae163784..09e520561 100644
--- a/serde_v8/tests/magic.rs
+++ b/serde_v8/tests/magic.rs
@@ -68,27 +68,26 @@ fn magic_buffer() {
// Simple buffer
let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
- let zbuf: serde_v8::ZeroCopyBuf =
- serde_v8::from_v8(scope, v8_array).unwrap();
+ let zbuf: serde_v8::JsBuffer = serde_v8::from_v8(scope, v8_array).unwrap();
assert_eq!(&*zbuf, &[1, 2, 3, 4, 5]);
// Multi buffers
let v8_arrays =
js_exec(scope, "[new Uint8Array([1,2]), new Uint8Array([3,4,5])]");
- let (z1, z2): (serde_v8::ZeroCopyBuf, serde_v8::ZeroCopyBuf) =
+ let (z1, z2): (serde_v8::JsBuffer, serde_v8::JsBuffer) =
serde_v8::from_v8(scope, v8_arrays).unwrap();
assert_eq!(&*z1, &[1, 2]);
assert_eq!(&*z2, &[3, 4, 5]);
// Wrapped in option, like our current op-ABI
let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
- let zbuf: Option<serde_v8::ZeroCopyBuf> =
+ let zbuf: Option<serde_v8::JsBuffer> =
serde_v8::from_v8(scope, v8_array).unwrap();
assert_eq!(&*zbuf.unwrap(), &[1, 2, 3, 4, 5]);
// Observe mutation in JS
let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
- let mut zbuf: serde_v8::ZeroCopyBuf =
+ let mut zbuf: serde_v8::JsBuffer =
serde_v8::from_v8(scope, v8_array).unwrap();
let key = serde_v8::to_v8(scope, "t1").unwrap();
global.set(scope, key, v8_array);
@@ -99,13 +98,12 @@ fn magic_buffer() {
// Shared buffers
let v8_array =
js_exec(scope, "new Uint8Array(new SharedArrayBuffer([1,2,3,4,5]))");
- let zbuf: Result<serde_v8::ZeroCopyBuf> =
- serde_v8::from_v8(scope, v8_array);
+ let zbuf: Result<serde_v8::JsBuffer> = serde_v8::from_v8(scope, v8_array);
assert!(zbuf.is_err());
// Serialization
let buf: Vec<u8> = vec![1, 2, 3, 99, 5];
- let zbuf: serde_v8::ZeroCopyBuf = buf.into();
+ let zbuf: serde_v8::ToJsBuffer = buf.into();
let v8_value = serde_v8::to_v8(scope, zbuf).unwrap();
let key = serde_v8::to_v8(scope, "t2").unwrap();
global.set(scope, key, v8_value);
@@ -115,8 +113,8 @@ fn magic_buffer() {
// Composite Serialization
#[derive(serde::Serialize)]
struct Wrapper {
- a: serde_v8::ZeroCopyBuf,
- b: serde_v8::ZeroCopyBuf,
+ a: serde_v8::ToJsBuffer,
+ b: serde_v8::ToJsBuffer,
}
let buf1: Vec<u8> = vec![1, 2, 33, 4, 5];
let buf2: Vec<u8> = vec![5, 4, 3, 2, 11];
@@ -134,8 +132,7 @@ fn magic_buffer() {
// ZeroCopyBuf as bytes::Bytes
let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
- let zbuf: serde_v8::ZeroCopyBuf =
- serde_v8::from_v8(scope, v8_array).unwrap();
+ let zbuf: serde_v8::JsBuffer = serde_v8::from_v8(scope, v8_array).unwrap();
let buf: bytes::Bytes = zbuf.into();
assert_eq!(buf, bytes::Bytes::from_static(&[1, 2, 3, 4, 5]));
assert_eq!(buf, bytes::Bytes::from_static(&[1, 2, 3, 4, 5]));
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 08:49:23 +0000