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.rs139
-rw-r--r--serde_v8/src/magic/field.rs144
-rw-r--r--serde_v8/src/magic/mod.rs8
-rw-r--r--serde_v8/src/magic/value.rs79
-rw-r--r--serde_v8/src/magic/zero_copy_buf.rs102
5 files changed, 0 insertions, 472 deletions
diff --git a/serde_v8/src/magic/buffer.rs b/serde_v8/src/magic/buffer.rs
deleted file mode 100644
index 1fcfffc72..000000000
--- a/serde_v8/src/magic/buffer.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use rusty_v8 as v8;
-
-use std::fmt;
-use std::ops::Deref;
-use std::ops::DerefMut;
-use std::sync::Mutex;
-
-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(Mutex<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))
- }
-
- pub fn empty() -> Self {
- MagicBuffer::ToV8(Mutex::new(Some(vec![0_u8; 0].into_boxed_slice())))
- }
-}
-
-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(Mutex::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(buf) => {
- let value: &[u8] = &buf;
- value.into()
- }
- Self::ToV8(x) => x.lock().unwrap().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/field.rs b/serde_v8/src/magic/field.rs
deleted file mode 100644
index e6bb9ee54..000000000
--- a/serde_v8/src/magic/field.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-use crate::error::{Error, Result};
-use serde::ser::{Impossible, Serialize, Serializer};
-
-/// All serde_v8 "magic" values are reduced to structs with 1 or 2 u64 fields
-/// assuming usize==u64, most types are simply a pointer or pointer+len (e.g: Box<T>)
-pub type TransmutedField = u64;
-pub type FieldResult = Result<TransmutedField>;
-
-macro_rules! not_reachable {
- ($($name:ident($ty:ty);)*) => {
- $(fn $name(self, _v: $ty) -> FieldResult {
- unreachable!();
- })*
- };
-}
-
-/// FieldSerializer is a simple serde::Serializer that only returns u64s
-/// it allows the "magic" struct serializers to obtain the transmuted field values
-pub struct FieldSerializer {}
-
-impl Serializer for FieldSerializer {
- type Ok = TransmutedField;
- type Error = Error;
-
- type SerializeSeq = Impossible<TransmutedField, Error>;
- type SerializeTuple = Impossible<TransmutedField, Error>;
- type SerializeTupleStruct = Impossible<TransmutedField, Error>;
- type SerializeTupleVariant = Impossible<TransmutedField, Error>;
- type SerializeMap = Impossible<TransmutedField, Error>;
- type SerializeStruct = Impossible<TransmutedField, Error>;
- type SerializeStructVariant = Impossible<TransmutedField, Error>;
-
- fn serialize_u64(self, transmuted_field: u64) -> FieldResult {
- Ok(transmuted_field)
- }
-
- not_reachable! {
- serialize_i8(i8);
- serialize_i16(i16);
- serialize_i32(i32);
- serialize_i64(i64);
- serialize_u8(u8);
- serialize_u16(u16);
- serialize_u32(u32);
- // serialize_u64(TransmutedField); the chosen one
- serialize_f32(f32);
- serialize_f64(f64);
- serialize_bool(bool);
- serialize_char(char);
- serialize_str(&str);
- serialize_bytes(&[u8]);
- }
-
- fn serialize_none(self) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_unit(self) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_unit_struct(self, _name: &'static str) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_unit_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- _variant: &'static str,
- ) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_newtype_struct<T: ?Sized + Serialize>(
- self,
- _name: &'static str,
- _value: &T,
- ) -> FieldResult {
- unreachable!();
- }
-
- fn serialize_newtype_variant<T: ?Sized + Serialize>(
- self,
- _name: &'static str,
- _variant_index: u32,
- _variant: &'static str,
- _value: &T,
- ) -> FieldResult {
- unreachable!();
- }
- fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
- unreachable!();
- }
-
- fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
- unreachable!();
- }
-
- fn serialize_tuple_struct(
- self,
- _name: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeTupleStruct> {
- unreachable!();
- }
-
- fn serialize_tuple_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- _variant: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeTupleVariant> {
- unreachable!();
- }
-
- fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
- unreachable!();
- }
-
- fn serialize_struct(
- self,
- _name: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeStruct> {
- unreachable!();
- }
-
- fn serialize_struct_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- _variant: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeStructVariant> {
- unreachable!();
- }
-}
diff --git a/serde_v8/src/magic/mod.rs b/serde_v8/src/magic/mod.rs
deleted file mode 100644
index 29c35a831..000000000
--- a/serde_v8/src/magic/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// 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/value.rs b/serde_v8/src/magic/value.rs
deleted file mode 100644
index 2cb622466..000000000
--- a/serde_v8/src/magic/value.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-use rusty_v8 as v8;
-
-use std::fmt;
-use std::marker::PhantomData;
-
-pub const FIELD: &str = "$__v8_magic_value";
-pub const NAME: &str = "$__v8_magic_Value";
-
-/// serde_v8::Value allows passing through `v8::Value`s untouched
-/// when encoding/decoding and allows mixing rust & v8 values in
-/// structs, tuples...
-/// The implementation mainly breaks down to:
-/// 1. Transmuting between u64 <> serde_v8::Value
-/// 2. Using special struct/field names to detect these values
-/// 3. Then serde "boilerplate"
-pub struct Value<'s> {
- pub v8_value: v8::Local<'s, v8::Value>,
-}
-
-impl<'s> From<v8::Local<'s, v8::Value>> for Value<'s> {
- fn from(v8_value: v8::Local<'s, v8::Value>) -> Self {
- Self { v8_value }
- }
-}
-
-impl<'s> From<Value<'s>> for v8::Local<'s, v8::Value> {
- fn from(v: Value<'s>) -> Self {
- v.v8_value
- }
-}
-
-impl serde::Serialize for Value<'_> {
- 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(NAME, 1)?;
- let mv = Value {
- v8_value: self.v8_value,
- };
- let hack: u64 = unsafe { std::mem::transmute(mv) };
- s.serialize_field(FIELD, &hack)?;
- s.end()
- }
-}
-
-impl<'de, 's> serde::Deserialize<'de> for Value<'s> {
- fn deserialize<D>(deserializer: D) -> Result<Value<'s>, D::Error>
- where
- D: serde::Deserializer<'de>,
- {
- struct ValueVisitor<'s> {
- p1: PhantomData<&'s ()>,
- }
-
- impl<'de, 's> serde::de::Visitor<'de> for ValueVisitor<'s> {
- type Value = Value<'s>;
-
- fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
- formatter.write_str("a v8::Value")
- }
-
- fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
- where
- E: serde::de::Error,
- {
- let mv: Value<'s> = unsafe { std::mem::transmute(v) };
- Ok(mv)
- }
- }
-
- static FIELDS: [&str; 1] = [FIELD];
- let visitor = ValueVisitor { p1: PhantomData };
- deserializer.deserialize_struct(NAME, &FIELDS, visitor)
- }
-}
diff --git a/serde_v8/src/magic/zero_copy_buf.rs b/serde_v8/src/magic/zero_copy_buf.rs
deleted file mode 100644
index 1f07292ba..000000000
--- a/serde_v8/src/magic/zero_copy_buf.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-// 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 15:18:19 +0000