From 6bb61fd8252b187778e2c3284a065ea9823343e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Haudebourg?= Date: Wed, 24 Jan 2024 16:20:16 +0100 Subject: [PATCH] Fix optional features. --- Cargo.toml | 8 +- examples/serde_json.rs | 22 +-- src/convert.rs | 3 - src/convert/serde_json.rs | 130 ++++------------- src/lib.rs | 7 +- src/serde.rs | 60 +------- src/serde/de.rs | 157 +++++--------------- src/serde/ser.rs | 300 +++++++++++--------------------------- 8 files changed, 173 insertions(+), 514 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index ddfceab..d192532 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "json-syntax" -version = "0.10.0" +version = "0.11.0" edition = "2021" authors = ["Timothée Haudebourg "] description = "Strict JSON parsing and mapping library" @@ -12,13 +12,13 @@ license = "MIT/Apache-2.0" readme = "README.md" [features] -# JSON Canonicalization Scheme (JCS) implementation. +## JSON Canonicalization Scheme (JCS) implementation. canonicalize = [ "ryu-js", "json-number/canonical" ] -# Serialization/Deserialization support using `serde`. +## Serialization/Deserialization support using `serde`. serde = [ "dep:serde", "json-number/serde" ] -# Compatibility layer with the `serde_json` crate. +## Compatibility layer with the `serde_json` crate. serde_json = [ "dep:serde_json", "json-number/serde_json" ] [dependencies] diff --git a/examples/serde_json.rs b/examples/serde_json.rs index a89f9b7..98ba1fd 100644 --- a/examples/serde_json.rs +++ b/examples/serde_json.rs @@ -9,27 +9,7 @@ fn main() { }); // We convert the `serde_json` value into a `json_syntax` value. - let b = json_syntax::Value::from_serde_json(a, |fragment| { - // `json_syntax` keeps metadata information attached to every value - // fragment, which `serde_json` does not. This is why this closure is - // necessary. It is called for every `serde_json` fragment to let you - // choose the metadata you want to associate to the fragment. - // This is intended to store code mapping information, but you can store - // any information. Here we store a text description of the fragment. - match fragment { - json_syntax::SerdeJsonFragment::Key(key) => { - format!("I'm an object key `{key}`") - } - json_syntax::SerdeJsonFragment::Value(value) => match value { - serde_json::Value::Null => "I'm the `null` value".to_string(), - serde_json::Value::Bool(b) => format!("I'm the boolean `{b:?}`"), - serde_json::Value::Number(n) => format!("I'm the number {n}"), - serde_json::Value::String(s) => format!("I'm the string {s:?}"), - serde_json::Value::Array(a) => format!("I'm an array of {} elements", a.len()), - serde_json::Value::Object(o) => format!("I'm an object of {} entries", o.len()), - }, - } - }); + let b = json_syntax::Value::from_serde_json(a); // We convert it back into a `serde_json` value. let _ = json_syntax::Value::into_serde_json(b); diff --git a/src/convert.rs b/src/convert.rs index da0c020..9b8194b 100644 --- a/src/convert.rs +++ b/src/convert.rs @@ -1,5 +1,2 @@ #[cfg(feature = "serde_json")] mod serde_json; - -#[cfg(feature = "serde_json")] -pub use self::serde_json::*; diff --git a/src/convert/serde_json.rs b/src/convert/serde_json.rs index f610008..7367652 100644 --- a/src/convert/serde_json.rs +++ b/src/convert/serde_json.rs @@ -1,21 +1,8 @@ -use locspan::Meta; - use crate::{object::Entry, Value}; -/// A fragment of a [`serde_json::Value`]. -/// -/// Used by the [`Value::from_serde_json`] to annotate the output value. -pub enum SerdeJsonFragment<'a> { - Key(&'a str), - Value(&'a serde_json::Value), -} - -impl Value { +impl Value { /// Converts a [`serde_json::Value`] into a `Value`. /// - /// The function `f` is used to annotate the output each sub value - /// (passed as parameter). - /// /// # Example /// /// ``` @@ -26,61 +13,29 @@ impl Value { /// }); /// /// // We convert the `serde_json` value into a `json_syntax` value. - /// let b = json_syntax::Value::from_serde_json(a, |fragment| { - /// // `json_syntax` keeps metadata information attached to every value - /// // fragment, which `serde_json` does not. This is why this closure is - /// // necessary. It is called for every `serde_json` fragment to let you - /// // choose the metadata you want to associate to the fragment. - /// // This is intended to store code mapping information, but you can store - /// // any information. Here we store a text description of the fragment. - /// match fragment { - /// json_syntax::SerdeJsonFragment::Key(key) => { - /// format!("I'm an object key `{key}`") - /// } - /// json_syntax::SerdeJsonFragment::Value(value) => match value { - /// serde_json::Value::Null => "I'm the `null` value".to_string(), - /// serde_json::Value::Bool(b) => format!("I'm the boolean `{b:?}`"), - /// serde_json::Value::Number(n) => format!("I'm the number {n}"), - /// serde_json::Value::String(s) => format!("I'm the string {s:?}"), - /// serde_json::Value::Array(a) => format!("I'm an array of {} elements", a.len()), - /// serde_json::Value::Object(o) => format!("I'm an object of {} entries", o.len()), - /// }, - /// } - /// }); + /// let b = json_syntax::Value::from_serde_json(a); /// /// // We convert it back into a `serde_json` value. /// let _ = json_syntax::Value::into_serde_json(b); /// ``` - pub fn from_serde_json( - value: serde_json::Value, - f: impl Clone + Fn(SerdeJsonFragment) -> M, - ) -> Meta { - let meta = f(SerdeJsonFragment::Value(&value)); - - let v = match value { + pub fn from_serde_json(value: serde_json::Value) -> Self { + match value { serde_json::Value::Null => Self::Null, serde_json::Value::Bool(b) => Self::Boolean(b), serde_json::Value::Number(n) => Self::Number(n.into()), serde_json::Value::String(s) => Self::String(s.into()), - serde_json::Value::Array(a) => Self::Array( - a.into_iter() - .map(|i| Self::from_serde_json(i, f.clone())) - .collect(), - ), + serde_json::Value::Array(a) => { + Self::Array(a.into_iter().map(Self::from_serde_json).collect()) + } serde_json::Value::Object(o) => Self::Object( o.into_iter() - .map(|(k, v)| { - let k_meta = f(SerdeJsonFragment::Key(&k)); - Entry::new(Meta(k.into(), k_meta), Self::from_serde_json(v, f.clone())) - }) + .map(|(k, v)| Entry::new(k.into(), Self::from_serde_json(v))) .collect(), ), - }; - - Meta(v, meta) + } } - /// Converts a `Value` into a [`serde_json::Value`], stripping the metadata. + /// Converts a `Value` into a [`serde_json::Value`]. /// /// # Example /// @@ -92,61 +47,38 @@ impl Value { /// }); /// /// // We convert the `serde_json` value into a `json_syntax` value. - /// let b = json_syntax::Value::from_serde_json(a, |fragment| { - /// // `json_syntax` keeps metadata information attached to every value - /// // fragment, which `serde_json` does not. This is why this closure is - /// // necessary. It is called for every `serde_json` fragment to let you - /// // choose the metadata you want to associate to the fragment. - /// // This is intended to store code mapping information, but you can store - /// // any information. Here we store a text description of the fragment. - /// match fragment { - /// json_syntax::SerdeJsonFragment::Key(key) => { - /// format!("I'm an object key `{key}`") - /// } - /// json_syntax::SerdeJsonFragment::Value(value) => match value { - /// serde_json::Value::Null => "I'm the `null` value".to_string(), - /// serde_json::Value::Bool(b) => format!("I'm the boolean `{b:?}`"), - /// serde_json::Value::Number(n) => format!("I'm the number {n}"), - /// serde_json::Value::String(s) => format!("I'm the string {s:?}"), - /// serde_json::Value::Array(a) => format!("I'm an array of {} elements", a.len()), - /// serde_json::Value::Object(o) => format!("I'm an object of {} entries", o.len()), - /// }, - /// } - /// }); + /// let b = json_syntax::Value::from_serde_json(a); /// /// // We convert it back into a `serde_json` value. /// let _ = json_syntax::Value::into_serde_json(b); /// ``` - pub fn into_serde_json(Meta(this, _): Meta) -> serde_json::Value { - this.into() + pub fn into_serde_json(self) -> serde_json::Value { + match self { + Self::Null => serde_json::Value::Null, + Self::Boolean(b) => serde_json::Value::Bool(b), + Self::Number(n) => serde_json::Value::Number(n.into()), + Self::String(s) => serde_json::Value::String(s.into_string()), + Self::Array(a) => { + serde_json::Value::Array(a.into_iter().map(Value::into_serde_json).collect()) + } + Self::Object(o) => serde_json::Value::Object( + o.into_iter() + .map(|Entry { key, value }| (key.into_string(), Value::into_serde_json(value))) + .collect(), + ), + } } } -impl From for Value { +impl From for Value { #[inline(always)] fn from(value: serde_json::Value) -> Self { - Value::from_serde_json(value, |_| M::default()).into_value() + Self::from_serde_json(value) } } -impl From> for serde_json::Value { - fn from(value: Value) -> Self { - match value { - Value::Null => Self::Null, - Value::Boolean(b) => Self::Bool(b), - Value::Number(n) => Self::Number(n.into()), - Value::String(s) => Self::String(s.into_string()), - Value::Array(a) => Self::Array(a.into_iter().map(Value::into_serde_json).collect()), - Value::Object(o) => Self::Object( - o.into_iter() - .map( - |Entry { - key: Meta(key, _), - value, - }| { (key.into_string(), Value::into_serde_json(value)) }, - ) - .collect(), - ), - } +impl From for serde_json::Value { + fn from(value: Value) -> Self { + value.into_serde_json() } } diff --git a/src/lib.rs b/src/lib.rs index bdc7ed8..af4be3a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -56,8 +56,6 @@ mod serde; #[cfg(feature = "serde")] pub use self::serde::*; -#[cfg(feature = "serde_json")] -pub use convert::*; pub use unordered::*; /// String stack capacity. @@ -713,7 +711,7 @@ mod tests { #[test] fn canonicalize_01() { use super::*; - let mut value: Meta, ()> = json!({ + let mut value: Value = json!({ "b": 0.00000000001, "c": { "foo": true, @@ -734,13 +732,12 @@ mod tests { #[test] fn canonicalize_02() { use super::*; - let mut value = Value::parse_str( + let (mut value, _) = Value::parse_str( "{ \"numbers\": [333333333.33333329, 1E30, 4.50, 2e-3, 0.000000000000000000000000001], \"string\": \"\\u20ac$\\u000F\\u000aA'\\u0042\\u0022\\u005c\\\\\\\"\\/\", \"literals\": [null, true, false] }", - |span| span, ) .unwrap(); diff --git a/src/serde.rs b/src/serde.rs index cfe27f2..30310d9 100644 --- a/src/serde.rs +++ b/src/serde.rs @@ -1,5 +1,4 @@ -use crate::{MetaValue, Value}; -use locspan::Meta; +use crate::Value; use serde::{de::DeserializeOwned, Serialize}; mod de; @@ -8,7 +7,7 @@ mod ser; pub use de::*; pub use ser::*; -/// Serializes the given `value` into a JSON [`Value`], with `()` as metadata. +/// Serializes the given `value` into a JSON [`Value`]. /// /// # Example /// @@ -30,7 +29,7 @@ pub use ser::*; /// let expected: Value = json!({ /// "fingerprint": "0xF9BA143B95FF6D82", /// "location": "Menlo Park, CA", -/// }).into_value(); +/// }); /// /// let v = json_syntax::to_value(u).unwrap(); /// assert_eq!(v, expected); @@ -39,53 +38,10 @@ pub fn to_value(value: T) -> Result where T: Serialize, { - Ok(value.serialize(Serializer::new(|| ()))?.into_value()) -} - -/// Serializes the given `value` into a JSON [`Value`] using the input -/// `metadata` function to annotate the output value. -pub fn to_value_with( - value: T, - metadata: impl Clone + Fn() -> M, -) -> Result, M>, SerializeError> -where - T: Serialize, -{ - value.serialize(Serializer::new(metadata)) -} - -/// Deserializes the JSON `value` into an instance of type `T`. -/// -/// # Example -/// -/// ``` -/// use serde::Deserialize; -/// use json_syntax::{json, Value}; -/// -/// #[derive(Deserialize, Debug)] -/// struct User { -/// fingerprint: String, -/// location: String, -/// } -/// -/// let j: Value = json!({ -/// "fingerprint": "0xF9BA143B95FF6D82", -/// "location": "Menlo Park, CA" -/// }).into_value(); -/// -/// let u: User = json_syntax::from_value(j).unwrap(); -/// println!("{:#?}", u); -/// ``` -pub fn from_value(value: Value) -> Result -where - T: DeserializeOwned, -{ - T::deserialize(value).map_err(DeserializeErrorFragment::strip) + value.serialize(Serializer) } /// Deserializes the JSON `value` into an instance of type `T`. -/// Contrarily to [`from_value`], on error this function will return the -/// metadata associated to the error location. /// /// # Example /// @@ -102,16 +58,14 @@ where /// let j: Value = json!({ /// "fingerprint": "0xF9BA143B95FF6D82", /// "location": "Menlo Park, CA" -/// }).into_value(); +/// }); /// /// let u: User = json_syntax::from_value(j).unwrap(); /// println!("{:#?}", u); /// ``` -pub fn from_meta_value( - Meta(value, meta): MetaValue, -) -> Result> +pub fn from_value(value: Value) -> Result where T: DeserializeOwned, { - T::deserialize(value).map_err(|e| e.with_metadata(meta)) + T::deserialize(value) } diff --git a/src/serde/de.rs b/src/serde/de.rs index 29746d4..eb8ef17 100644 --- a/src/serde/de.rs +++ b/src/serde/de.rs @@ -1,6 +1,3 @@ -use std::fmt; - -use locspan::Meta; use serde::{ de::{ DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess, Unexpected, @@ -8,13 +5,14 @@ use serde::{ }, forward_to_deserialize_any, Deserialize, }; +use std::fmt; use crate::{ object::{Entry, Key}, Array, NumberBuf, Object, Value, }; -impl Value { +impl Value { #[cold] fn invalid_type(&self, exp: &dyn Expected) -> E where @@ -118,7 +116,7 @@ impl<'de> Deserialize<'de> for Value { let mut vec = Vec::new(); while let Some(elem) = visitor.next_element()? { - vec.push(Meta(elem, ())); + vec.push(elem); } Ok(Value::Array(vec)) @@ -159,7 +157,7 @@ impl<'de> Deserialize<'de> for Value { } } -impl<'de, M> IntoDeserializer<'de, DeserializeErrorFragment> for Value { +impl<'de> IntoDeserializer<'de, DeserializeError> for Value { type Deserializer = Self; fn into_deserializer(self) -> Self::Deserializer { @@ -173,45 +171,6 @@ pub enum DeserializeError { NonStringKey, } -pub enum DeserializeErrorFragment { - Outer(DeserializeError), - Inner(Meta), -} - -impl DeserializeErrorFragment { - pub fn strip(self) -> DeserializeError { - match self { - Self::Outer(e) => e, - Self::Inner(Meta(e, _)) => e, - } - } - - pub fn with_metadata(self, meta: M) -> Meta { - match self { - Self::Outer(e) => Meta(e, meta), - Self::Inner(e) => e, - } - } -} - -impl From for DeserializeErrorFragment { - fn from(value: DeserializeError) -> Self { - Self::Outer(value) - } -} - -impl From> for DeserializeErrorFragment { - fn from(value: Meta) -> Self { - Self::Inner(value) - } -} - -impl From for DeserializeErrorFragment { - fn from(u: json_number::serde::Unexpected) -> Self { - DeserializeError::Custom(u.to_string()).into() - } -} - impl fmt::Display for DeserializeError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { @@ -221,37 +180,14 @@ impl fmt::Display for DeserializeError { } } -impl fmt::Debug for DeserializeErrorFragment { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Self::Outer(e) => e.fmt(f), - Self::Inner(Meta(e, _)) => e.fmt(f), - } - } -} - -impl fmt::Display for DeserializeErrorFragment { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Self::Outer(e) => e.fmt(f), - Self::Inner(Meta(e, _)) => e.fmt(f), - } +impl From for DeserializeError { + fn from(value: json_number::serde::Unexpected) -> Self { + Self::Custom(value.to_string()) } } -impl std::error::Error for DeserializeErrorFragment {} - impl std::error::Error for DeserializeError {} -impl serde::de::Error for DeserializeErrorFragment { - fn custom(msg: T) -> Self - where - T: fmt::Display, - { - DeserializeError::Custom(msg.to_string()).into() - } -} - impl serde::de::Error for DeserializeError { fn custom(msg: T) -> Self where @@ -275,8 +211,8 @@ macro_rules! deserialize_number { }; } -impl<'de, M> serde::Deserializer<'de> for Value { - type Error = DeserializeErrorFragment; +impl<'de> serde::Deserializer<'de> for Value { + type Error = DeserializeError; #[inline] fn deserialize_any(self, visitor: V) -> Result @@ -331,8 +267,8 @@ impl<'de, M> serde::Deserializer<'de> for Value { Value::Object(value) => { let mut iter = value.into_iter(); let Entry { - key: Meta(variant, _), - value: Meta(value, _), + key: variant, + value, } = match iter.next() { Some(v) => v, None => { @@ -519,7 +455,7 @@ impl<'de, M> serde::Deserializer<'de> for Value { } } -fn visit_array<'de, M, V>(a: Array, visitor: V) -> Result> +fn visit_array<'de, V>(a: Array, visitor: V) -> Result where V: serde::de::Visitor<'de>, { @@ -537,10 +473,7 @@ where } } -fn visit_object<'de, M, V>( - o: Object, - visitor: V, -) -> Result> +fn visit_object<'de, V>(o: Object, visitor: V) -> Result where V: serde::de::Visitor<'de>, { @@ -558,30 +491,27 @@ where } } -struct ArrayDeserializer { - iter: std::vec::IntoIter, M>>, +struct ArrayDeserializer { + iter: std::vec::IntoIter, } -impl ArrayDeserializer { - fn new(array: Array) -> Self { +impl ArrayDeserializer { + fn new(array: Array) -> Self { Self { iter: array.into_iter(), } } } -impl<'de, M> SeqAccess<'de> for ArrayDeserializer { - type Error = DeserializeErrorFragment; +impl<'de> SeqAccess<'de> for ArrayDeserializer { + type Error = DeserializeError; fn next_element_seed(&mut self, seed: T) -> Result, Self::Error> where T: DeserializeSeed<'de>, { match self.iter.next() { - Some(Meta(value, meta)) => seed - .deserialize(value) - .map_err(|e| e.with_metadata(meta).into()) - .map(Some), + Some(value) => seed.deserialize(value).map(Some), None => Ok(None), } } @@ -594,13 +524,13 @@ impl<'de, M> SeqAccess<'de> for ArrayDeserializer { } } -struct ObjectDeserializer { - iter: std::vec::IntoIter>, - value: Option, M>>, +struct ObjectDeserializer { + iter: std::vec::IntoIter, + value: Option, } -impl ObjectDeserializer { - fn new(obj: Object) -> Self { +impl ObjectDeserializer { + fn new(obj: Object) -> Self { Self { iter: obj.into_iter(), value: None, @@ -608,23 +538,18 @@ impl ObjectDeserializer { } } -impl<'de, M> MapAccess<'de> for ObjectDeserializer { - type Error = DeserializeErrorFragment; +impl<'de> MapAccess<'de> for ObjectDeserializer { + type Error = DeserializeError; fn next_key_seed(&mut self, seed: T) -> Result, Self::Error> where T: DeserializeSeed<'de>, { match self.iter.next() { - Some(Entry { - key: Meta(key, key_meta), - value, - }) => { + Some(Entry { key, value }) => { self.value = Some(value); let key_de = MapKeyDeserializer { key }; - seed.deserialize(key_de) - .map_err(|e| DeserializeErrorFragment::Inner(Meta(e, key_meta))) - .map(Some) + seed.deserialize(key_de).map(Some) } None => Ok(None), } @@ -635,9 +560,7 @@ impl<'de, M> MapAccess<'de> for ObjectDeserializer { T: DeserializeSeed<'de>, { match self.value.take() { - Some(Meta(value, meta)) => seed - .deserialize(value) - .map_err(|e| e.with_metadata(meta).into()), + Some(value) => seed.deserialize(value), None => Err(serde::de::Error::custom("value is missing")), } } @@ -730,16 +653,16 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer { } } -struct EnumDeserializer { +struct EnumDeserializer { variant: Key, - value: Option>, + value: Option, } -impl<'de, M> EnumAccess<'de> for EnumDeserializer { - type Error = DeserializeErrorFragment; - type Variant = VariantDeserializer; +impl<'de> EnumAccess<'de> for EnumDeserializer { + type Error = DeserializeError; + type Variant = VariantDeserializer; - fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error> + fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error> where V: DeserializeSeed<'de>, { @@ -749,12 +672,12 @@ impl<'de, M> EnumAccess<'de> for EnumDeserializer { } } -struct VariantDeserializer { - value: Option>, +struct VariantDeserializer { + value: Option, } -impl<'de, M> VariantAccess<'de> for VariantDeserializer { - type Error = DeserializeErrorFragment; +impl<'de> VariantAccess<'de> for VariantDeserializer { + type Error = DeserializeError; fn unit_variant(self) -> Result<(), Self::Error> { match self.value { diff --git a/src/serde/ser.rs b/src/serde/ser.rs index 111ca7b..e58f971 100644 --- a/src/serde/ser.rs +++ b/src/serde/ser.rs @@ -1,11 +1,10 @@ -use locspan::Meta; use serde::{ser::Impossible, Serialize}; use smallstr::SmallString; use std::fmt; use crate::{object::Key, Array, NumberBuf, Object, Value}; -impl Serialize for Value { +impl Serialize for Value { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer, @@ -20,7 +19,7 @@ impl Serialize for Value { let mut seq = serializer.serialize_seq(Some(a.len()))?; for item in a { - seq.serialize_element(item.value())? + seq.serialize_element(item)? } seq.end() @@ -30,7 +29,7 @@ impl Serialize for Value { } } -impl Serialize for Object { +impl Serialize for Object { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer, @@ -39,7 +38,7 @@ impl Serialize for Object { let mut map = serializer.serialize_map(Some(self.len()))?; for entry in self { - map.serialize_entry(entry.key.as_str(), entry.stripped_value())?; + map.serialize_entry(entry.key.as_str(), &entry.value)?; } map.end() @@ -73,43 +72,23 @@ impl serde::ser::Error for SerializeError { } /// [`Value`] serializer. -pub struct Serializer { - metadata_builder: F, -} - -impl Serializer -where - F: Fn() -> M, -{ - /// Creates a new [`Value`] serializer using the given function to - /// annotate the output value. - pub fn new(metadata_builder: F) -> Self { - Self { metadata_builder } - } - - fn build_metadata(&self) -> M { - (self.metadata_builder)() - } -} +pub struct Serializer; -impl serde::Serializer for Serializer -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::Serializer for Serializer { + type Ok = Value; type Error = SerializeError; - type SerializeSeq = SerializeArray; - type SerializeTuple = SerializeArray; - type SerializeTupleStruct = SerializeArray; - type SerializeTupleVariant = SerializeTupleVariant; - type SerializeMap = SerializeObject; - type SerializeStruct = SerializeObject; - type SerializeStructVariant = SerializeStructVariant; + type SerializeSeq = SerializeArray; + type SerializeTuple = SerializeArray; + type SerializeTupleStruct = SerializeArray; + type SerializeTupleVariant = SerializeTupleVariant; + type SerializeMap = SerializeObject; + type SerializeStruct = SerializeObject; + type SerializeStructVariant = SerializeStructVariant; #[inline(always)] fn serialize_bool(self, v: bool) -> Result { - Ok(Meta(Value::Boolean(v), self.build_metadata())) + Ok(Value::Boolean(v)) } #[inline(always)] @@ -129,7 +108,7 @@ where #[inline(always)] fn serialize_i64(self, v: i64) -> Result { - Ok(Meta(Value::Number(v.into()), self.build_metadata())) + Ok(Value::Number(v.into())) } #[inline(always)] @@ -149,53 +128,44 @@ where #[inline(always)] fn serialize_u64(self, v: u64) -> Result { - Ok(Meta(Value::Number(v.into()), self.build_metadata())) + Ok(Value::Number(v.into())) } #[inline(always)] fn serialize_f32(self, v: f32) -> Result { - Ok(Meta( - NumberBuf::try_from(v) - .map(Value::Number) - .unwrap_or(Value::Null), - self.build_metadata(), - )) + Ok(NumberBuf::try_from(v) + .map(Value::Number) + .unwrap_or(Value::Null)) } #[inline(always)] fn serialize_f64(self, v: f64) -> Result { - Ok(Meta( - NumberBuf::try_from(v) - .map(Value::Number) - .unwrap_or(Value::Null), - self.build_metadata(), - )) + Ok(NumberBuf::try_from(v) + .map(Value::Number) + .unwrap_or(Value::Null)) } #[inline(always)] fn serialize_char(self, v: char) -> Result { let mut s = SmallString::new(); s.push(v); - Ok(Meta(Value::String(s), self.build_metadata())) + Ok(Value::String(s)) } #[inline(always)] fn serialize_str(self, v: &str) -> Result { - Ok(Meta(Value::String(v.into()), self.build_metadata())) + Ok(Value::String(v.into())) } #[inline(always)] fn serialize_bytes(self, v: &[u8]) -> Result { - let vec = v - .iter() - .map(|&b| Meta(Value::Number(b.into()), self.build_metadata())) - .collect(); - Ok(Meta(Value::Array(vec), self.build_metadata())) + let vec = v.iter().map(|&b| Value::Number(b.into())).collect(); + Ok(Value::Array(vec)) } #[inline(always)] fn serialize_unit(self) -> Result { - Ok(Meta(Value::Null, self.build_metadata())) + Ok(Value::Null) } #[inline(always)] @@ -237,10 +207,8 @@ where T: Serialize, { let mut obj = Object::new(); - let meta = self.build_metadata(); - let key_metadata = self.build_metadata(); - obj.insert(Meta(variant.into(), key_metadata), value.serialize(self)?); - Ok(Meta(Value::Object(obj), meta)) + obj.insert(variant.into(), value.serialize(self)?); + Ok(Value::Object(obj)) } #[inline(always)] @@ -260,7 +228,6 @@ where fn serialize_seq(self, len: Option) -> Result { Ok(SerializeArray { array: Vec::with_capacity(len.unwrap_or(0)), - metadata_builder: self.metadata_builder, }) } @@ -288,7 +255,6 @@ where Ok(SerializeTupleVariant { name: variant.into(), array: Vec::with_capacity(len), - metadata_builder: self.metadata_builder, }) } @@ -296,7 +262,6 @@ where Ok(SerializeObject { obj: Object::new(), next_key: None, - metadata_builder: self.metadata_builder, }) } @@ -318,7 +283,6 @@ where Ok(SerializeStructVariant { name: variant.into(), obj: Object::new(), - metadata_builder: self.metadata_builder, }) } @@ -326,26 +290,23 @@ where where T: fmt::Display, { - Ok(Meta( - Value::String(value.to_string().into()), - self.build_metadata(), - )) + Ok(Value::String(value.to_string().into())) } } -pub struct KeySerializer(M); +pub struct KeySerializer; -impl serde::Serializer for KeySerializer { - type Ok = Meta; +impl serde::Serializer for KeySerializer { + type Ok = Key; type Error = SerializeError; - type SerializeSeq = Impossible, SerializeError>; - type SerializeTuple = Impossible, SerializeError>; - type SerializeTupleStruct = Impossible, SerializeError>; - type SerializeTupleVariant = Impossible, SerializeError>; - type SerializeMap = Impossible, SerializeError>; - type SerializeStruct = Impossible, SerializeError>; - type SerializeStructVariant = Impossible, SerializeError>; + type SerializeSeq = Impossible; + type SerializeTuple = Impossible; + type SerializeTupleStruct = Impossible; + type SerializeTupleVariant = Impossible; + type SerializeMap = Impossible; + type SerializeStruct = Impossible; + type SerializeStructVariant = Impossible; #[inline] fn serialize_unit_variant( @@ -354,7 +315,7 @@ impl serde::Serializer for KeySerializer { _variant_index: u32, variant: &'static str, ) -> Result { - Ok(Meta(variant.into(), self.0)) + Ok(variant.into()) } #[inline] @@ -374,35 +335,35 @@ impl serde::Serializer for KeySerializer { } fn serialize_i8(self, value: i8) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_i16(self, value: i16) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_i32(self, value: i32) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_i64(self, value: i64) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_u8(self, value: u8) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_u16(self, value: u16) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_u32(self, value: u32) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_u64(self, value: u64) -> Result { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } fn serialize_f32(self, _value: f32) -> Result { @@ -417,12 +378,12 @@ impl serde::Serializer for KeySerializer { fn serialize_char(self, value: char) -> Result { let mut s = Key::new(); s.push(value); - Ok(Meta(s, self.0)) + Ok(s) } #[inline] fn serialize_str(self, value: &str) -> Result { - Ok(Meta(value.into(), self.0)) + Ok(value.into()) } fn serialize_bytes(self, _value: &[u8]) -> Result { @@ -513,51 +474,33 @@ impl serde::Serializer for KeySerializer { where T: ?Sized + fmt::Display, { - Ok(Meta(value.to_string().into(), self.0)) + Ok(value.to_string().into()) } } -pub struct SerializeArray { - array: Array, - metadata_builder: F, +pub struct SerializeArray { + array: Array, } -impl SerializeArray -where - F: Fn() -> M, -{ - fn build_metadata(&self) -> M { - (self.metadata_builder)() - } -} - -impl serde::ser::SerializeSeq for SerializeArray -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeSeq for SerializeArray { + type Ok = Value; type Error = SerializeError; fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> where T: Serialize, { - self.array - .push(value.serialize(Serializer::new(self.metadata_builder.clone()))?); + self.array.push(value.serialize(Serializer)?); Ok(()) } fn end(self) -> Result { - let meta = self.build_metadata(); - Ok(Meta(Value::Array(self.array), meta)) + Ok(Value::Array(self.array)) } } -impl serde::ser::SerializeTuple for SerializeArray -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeTuple for SerializeArray { + type Ok = Value; type Error = SerializeError; fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> @@ -572,11 +515,8 @@ where } } -impl serde::ser::SerializeTupleStruct for SerializeArray -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeTupleStruct for SerializeArray { + type Ok = Value; type Error = SerializeError; fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> @@ -591,72 +531,38 @@ where } } -pub struct SerializeTupleVariant { +pub struct SerializeTupleVariant { name: Key, - array: Array, - metadata_builder: F, -} - -impl SerializeTupleVariant -where - F: Fn() -> M, -{ - fn build_metadata(&self) -> M { - (self.metadata_builder)() - } + array: Array, } -impl serde::ser::SerializeTupleVariant for SerializeTupleVariant -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeTupleVariant for SerializeTupleVariant { + type Ok = Value; type Error = SerializeError; fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> where T: Serialize, { - self.array - .push(value.serialize(Serializer::new(self.metadata_builder.clone()))?); + self.array.push(value.serialize(Serializer)?); Ok(()) } fn end(self) -> Result { let mut obj = Object::new(); + obj.insert(self.name, Value::Array(self.array)); - let key_meta = self.build_metadata(); - let value_meta = self.build_metadata(); - let meta = self.build_metadata(); - obj.insert( - Meta(self.name, key_meta), - Meta(Value::Array(self.array), value_meta), - ); - - Ok(Meta(Value::Object(obj), meta)) + Ok(Value::Object(obj)) } } -pub struct SerializeStructVariant { +pub struct SerializeStructVariant { name: Key, - obj: Object, - metadata_builder: F, -} - -impl SerializeStructVariant -where - F: Fn() -> M, -{ - fn build_metadata(&self) -> M { - (self.metadata_builder)() - } + obj: Object, } -impl serde::ser::SerializeStructVariant for SerializeStructVariant -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeStructVariant for SerializeStructVariant { + type Ok = Value; type Error = SerializeError; fn serialize_field( @@ -667,56 +573,33 @@ where where T: Serialize, { - let key = Meta(key.into(), self.build_metadata()); - self.obj.insert( - key, - value.serialize(Serializer::new(self.metadata_builder.clone()))?, - ); + let key = key.into(); + self.obj.insert(key, value.serialize(Serializer)?); Ok(()) } fn end(self) -> Result { let mut obj = Object::new(); + obj.insert(self.name, Value::Object(self.obj)); - let key_meta = self.build_metadata(); - let value_meta = self.build_metadata(); - let meta = self.build_metadata(); - obj.insert( - Meta(self.name, key_meta), - Meta(Value::Object(self.obj), value_meta), - ); - - Ok(Meta(Value::Object(obj), meta)) + Ok(Value::Object(obj)) } } -pub struct SerializeObject { - obj: Object, - next_key: Option>, - metadata_builder: F, -} - -impl SerializeObject -where - F: Fn() -> M, -{ - fn build_metadata(&self) -> M { - (self.metadata_builder)() - } +pub struct SerializeObject { + obj: Object, + next_key: Option, } -impl serde::ser::SerializeMap for SerializeObject -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeMap for SerializeObject { + type Ok = Value; type Error = SerializeError; fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> where T: Serialize, { - self.next_key = Some(key.serialize(KeySerializer(self.build_metadata()))?); + self.next_key = Some(key.serialize(KeySerializer)?); Ok(()) } @@ -728,24 +611,17 @@ where .next_key .take() .expect("serialize_value called before serialize_key"); - self.obj.insert( - key, - value.serialize(Serializer::new(self.metadata_builder.clone()))?, - ); + self.obj.insert(key, value.serialize(Serializer)?); Ok(()) } fn end(self) -> Result { - let meta = self.build_metadata(); - Ok(Meta(Value::Object(self.obj), meta)) + Ok(Value::Object(self.obj)) } } -impl serde::ser::SerializeStruct for SerializeObject -where - F: Clone + Fn() -> M, -{ - type Ok = Meta, M>; +impl serde::ser::SerializeStruct for SerializeObject { + type Ok = Value; type Error = SerializeError; fn serialize_field(