summaryrefslogtreecommitdiff
path: root/serde_v8/src/magic
diff options
context:
space:
mode:
Diffstat (limited to 'serde_v8/src/magic')
-rw-r--r--serde_v8/src/magic/buffer.rs132
-rw-r--r--serde_v8/src/magic/mod.rs2
-rw-r--r--serde_v8/src/magic/zero_copy_buf.rs102
3 files changed, 236 insertions, 0 deletions
diff --git a/serde_v8/src/magic/buffer.rs b/serde_v8/src/magic/buffer.rs
new file mode 100644
index 000000000..893bf35e1
--- /dev/null
+++ b/serde_v8/src/magic/buffer.rs
@@ -0,0 +1,132 @@
+use rusty_v8 as v8;
+
+use std::cell::Cell;
+use std::fmt;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+use super::zero_copy_buf::ZeroCopyBuf;
+
+// An asymmetric wrapper around ZeroCopyBuf,
+// allowing us to use a single type for familiarity
+pub enum MagicBuffer {
+ FromV8(ZeroCopyBuf),
+ ToV8(Cell<Option<Box<[u8]>>>),
+}
+
+impl MagicBuffer {
+ pub fn new<'s>(
+ scope: &mut v8::HandleScope<'s>,
+ view: v8::Local<v8::ArrayBufferView>,
+ ) -> Self {
+ Self::FromV8(ZeroCopyBuf::new(scope, view))
+ }
+}
+
+impl Clone for MagicBuffer {
+ fn clone(&self) -> Self {
+ match self {
+ Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
+ Self::ToV8(_) => panic!("Don't Clone a MagicBuffer sent to v8"),
+ }
+ }
+}
+
+impl AsRef<[u8]> for MagicBuffer {
+ fn as_ref(&self) -> &[u8] {
+ &*self
+ }
+}
+
+impl AsMut<[u8]> for MagicBuffer {
+ fn as_mut(&mut self) -> &mut [u8] {
+ &mut *self
+ }
+}
+
+impl Deref for MagicBuffer {
+ type Target = [u8];
+ fn deref(&self) -> &[u8] {
+ match self {
+ Self::FromV8(buf) => &*buf,
+ Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+ }
+ }
+}
+
+impl DerefMut for MagicBuffer {
+ fn deref_mut(&mut self) -> &mut [u8] {
+ match self {
+ Self::FromV8(buf) => &mut *buf,
+ Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+ }
+ }
+}
+
+impl From<Box<[u8]>> for MagicBuffer {
+ fn from(buf: Box<[u8]>) -> Self {
+ MagicBuffer::ToV8(Cell::new(Some(buf)))
+ }
+}
+
+impl From<Vec<u8>> for MagicBuffer {
+ fn from(vec: Vec<u8>) -> Self {
+ vec.into_boxed_slice().into()
+ }
+}
+
+pub const BUF_NAME: &str = "$__v8_magic_Buffer";
+pub const BUF_FIELD_1: &str = "$__v8_magic_buffer_1";
+pub const BUF_FIELD_2: &str = "$__v8_magic_buffer_2";
+
+impl serde::Serialize for MagicBuffer {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ use serde::ser::SerializeStruct;
+
+ let mut s = serializer.serialize_struct(BUF_NAME, 1)?;
+ let boxed: Box<[u8]> = match self {
+ Self::FromV8(_) => unreachable!(),
+ Self::ToV8(x) => x.take().expect("MagicBuffer was empty"),
+ };
+ let hack: [usize; 2] = unsafe { std::mem::transmute(boxed) };
+ let f1: u64 = hack[0] as u64;
+ let f2: u64 = hack[1] as u64;
+ s.serialize_field(BUF_FIELD_1, &f1)?;
+ s.serialize_field(BUF_FIELD_2, &f2)?;
+ s.end()
+ }
+}
+
+impl<'de, 's> serde::Deserialize<'de> for MagicBuffer {
+ fn deserialize<D>(deserializer: D) -> Result<MagicBuffer, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct ValueVisitor {}
+
+ impl<'de> serde::de::Visitor<'de> for ValueVisitor {
+ type Value = MagicBuffer;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a serde_v8::MagicBuffer")
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+ where
+ E: serde::de::Error,
+ {
+ let p1: &[usize] = unsafe { &*(v as *const [u8] as *const [usize]) };
+ let p2: [usize; 4] = [p1[0], p1[1], p1[2], p1[3]];
+ let zero_copy: ZeroCopyBuf = unsafe { std::mem::transmute(p2) };
+ Ok(MagicBuffer::FromV8(zero_copy))
+ }
+ }
+
+ static FIELDS: [&str; 0] = [];
+ let visitor = ValueVisitor {};
+ deserializer.deserialize_struct(BUF_NAME, &FIELDS, visitor)
+ }
+}
diff --git a/serde_v8/src/magic/mod.rs b/serde_v8/src/magic/mod.rs
index 50a971939..29c35a831 100644
--- a/serde_v8/src/magic/mod.rs
+++ b/serde_v8/src/magic/mod.rs
@@ -1,6 +1,8 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+pub mod buffer;
mod field;
mod value;
+pub mod zero_copy_buf;
pub use field::FieldSerializer;
pub use value::{Value, FIELD, NAME};
diff --git a/serde_v8/src/magic/zero_copy_buf.rs b/serde_v8/src/magic/zero_copy_buf.rs
new file mode 100644
index 000000000..1f07292ba
--- /dev/null
+++ b/serde_v8/src/magic/zero_copy_buf.rs
@@ -0,0 +1,102 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+use rusty_v8 as v8;
+use std::cell::Cell;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+/// A ZeroCopyBuf encapsulates a slice that's been borrowed from a JavaScript
+/// ArrayBuffer object. JavaScript objects can normally be garbage collected,
+/// but the existence of a ZeroCopyBuf inhibits this until it is dropped. It
+/// behaves much like an Arc<[u8]>.
+///
+/// # Cloning
+/// Cloning a ZeroCopyBuf does not clone the contents of the buffer,
+/// it creates a new reference to that buffer.
+///
+/// To actually clone the contents of the buffer do
+/// `let copy = Vec::from(&*zero_copy_buf);`
+#[derive(Clone)]
+pub struct ZeroCopyBuf {
+ backing_store: v8::SharedRef<v8::BackingStore>,
+ byte_offset: usize,
+ byte_length: usize,
+}
+
+unsafe impl Send for ZeroCopyBuf {}
+
+impl ZeroCopyBuf {
+ pub fn new<'s>(
+ scope: &mut v8::HandleScope<'s>,
+ view: v8::Local<v8::ArrayBufferView>,
+ ) -> Self {
+ let backing_store = view.buffer(scope).unwrap().get_backing_store();
+ let byte_offset = view.byte_offset();
+ let byte_length = view.byte_length();
+ Self {
+ backing_store,
+ byte_offset,
+ byte_length,
+ }
+ }
+}
+
+impl Deref for ZeroCopyBuf {
+ type Target = [u8];
+ fn deref(&self) -> &[u8] {
+ unsafe {
+ get_backing_store_slice(
+ &self.backing_store,
+ self.byte_offset,
+ self.byte_length,
+ )
+ }
+ }
+}
+
+impl DerefMut for ZeroCopyBuf {
+ fn deref_mut(&mut self) -> &mut [u8] {
+ unsafe {
+ get_backing_store_slice_mut(
+ &self.backing_store,
+ self.byte_offset,
+ self.byte_length,
+ )
+ }
+ }
+}
+
+impl AsRef<[u8]> for ZeroCopyBuf {
+ fn as_ref(&self) -> &[u8] {
+ &*self
+ }
+}
+
+impl AsMut<[u8]> for ZeroCopyBuf {
+ fn as_mut(&mut self) -> &mut [u8] {
+ &mut *self
+ }
+}
+
+unsafe fn get_backing_store_slice(
+ backing_store: &v8::SharedRef<v8::BackingStore>,
+ byte_offset: usize,
+ byte_length: usize,
+) -> &[u8] {
+ let cells: *const [Cell<u8>] =
+ &backing_store[byte_offset..byte_offset + byte_length];
+ let bytes = cells as *const [u8];
+ &*bytes
+}
+
+#[allow(clippy::mut_from_ref)]
+unsafe fn get_backing_store_slice_mut(
+ backing_store: &v8::SharedRef<v8::BackingStore>,
+ byte_offset: usize,
+ byte_length: usize,
+) -> &mut [u8] {
+ let cells: *const [Cell<u8>] =
+ &backing_store[byte_offset..byte_offset + byte_length];
+ let bytes = cells as *const _ as *mut [u8];
+ &mut *bytes
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-03 10:13:16 +0000