syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Less ownership in preserves::ser::Serializer

This commit is contained in:
Tony Garnock-Jones 2020-05-24 21:17:41 +02:00
parent fdae09b44c
commit 92463c37d4
3 changed files with 30 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
implementations/rust/Cargo.toml
View File

@ -16,3 +16,4 @@ num = "0.2"
num_enum = "0.4.1" num_enum = "0.4.1"
serde = { version = "1.0", features = ["derive"] } serde = { version = "1.0", features = ["derive"] }
serde_bytes = "0.11" serde_bytes = "0.11"
bytes = "0.5.4"

2
implementations/rust/src/lib.rs
View File

@ -402,7 +402,7 @@ mod samples_tests {
placeholders.insert(0, Value::symbol("SimpleValue")); placeholders.insert(0, Value::symbol("SimpleValue"));
let v_bytes_1 = Codec::new(placeholders.clone()).encode_bytes(&w).unwrap(); let v_bytes_1 = Codec::new(placeholders.clone()).encode_bytes(&w).unwrap();
let mut v_bytes_2 = Vec::new(); let mut v_bytes_2 = Vec::new();
v.serialize(&mut crate::ser::Serializer::new(&mut v_bytes_2, &placeholders)).unwrap(); v.serialize(&mut crate::ser::Serializer::new(&mut v_bytes_2, Some(&crate::value::invert_map(&placeholders)))).unwrap();
println!("== w bytes = {:?}", v_bytes_1); println!("== w bytes = {:?}", v_bytes_1);
println!("== v bytes = {:?}", v_bytes_2); println!("== v bytes = {:?}", v_bytes_2);
assert_eq!(v_bytes_1, v_bytes_2); assert_eq!(v_bytes_1, v_bytes_2);

61
implementations/rust/src/ser.rs
View File

@ -3,7 +3,7 @@ use super::value::writer::{self, Writer};
use super::value::{ use super::value::{
Value, NestedValue, PlainValue, Value, NestedValue, PlainValue,
Domain, NullDomain, Domain, NullDomain,
DecodePlaceholderMap, EncodePlaceholderMap, invert_map, EncodePlaceholderMap,
Encoder, Encoder,
}; };
@ -41,14 +41,14 @@ impl std::fmt::Display for Error {
impl std::error::Error for Error {} impl std::error::Error for Error {}
#[derive(Debug)] #[derive(Debug)]
pub struct Serializer<W: Writer, N: NestedValue<D>, D: Domain> { pub struct Serializer<'a, W: Writer, N: NestedValue<D>, D: Domain> {
pub write: W, pub write: &'a mut W,
placeholders: Option<EncodePlaceholderMap<N, D>>, placeholders: Option<&'a EncodePlaceholderMap<N, D>>,
} }
impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> { impl<'a, W: Writer, N: NestedValue<D>, D: Domain> Serializer<'a, W, N, D> {
pub fn new(write: W, placeholders: &DecodePlaceholderMap<N, D>) -> Self { pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap<N, D>>) -> Self {
Serializer { write, placeholders: Some(invert_map(&placeholders)) } Serializer { write, placeholders }
} }
fn write_symbol(&mut self, s: &str) -> Result<()> { fn write_symbol(&mut self, s: &str) -> Result<()> {
@ -57,28 +57,24 @@ impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
None => Ok(self.write.write_symbol(s)?), None => Ok(self.write.write_symbol(s)?),
} }
} }
pub fn without_placeholders(write: W) -> Self {
Serializer { write, placeholders: None }
}
} }
#[derive(Debug)] #[derive(Debug)]
pub struct SerializeCompound<'a, W: Writer, N: NestedValue<D>, D: Domain> { pub struct SerializeCompound<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> {
ser: &'a mut Serializer<W, N, D>, ser: &'a mut Serializer<'b, W, N, D>,
count: Option<usize>, count: Option<usize>,
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
type SerializeSeq = SerializeCompound<'a, W, N, D>; type SerializeSeq = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTuple = SerializeCompound<'a, W, N, D>; type SerializeTuple = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTupleStruct = SerializeCompound<'a, W, N, D>; type SerializeTupleStruct = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTupleVariant = SerializeCompound<'a, W, N, D>; type SerializeTupleVariant = SerializeCompound<'a, 'b, W, N, D>;
type SerializeMap = SerializeCompound<'a, W, N, D>; type SerializeMap = SerializeCompound<'a, 'b, W, N, D>;
type SerializeStruct = SerializeCompound<'a, W, N, D>; type SerializeStruct = SerializeCompound<'a, 'b, W, N, D>;
type SerializeStructVariant = SerializeCompound<'a, W, N, D>; type SerializeStructVariant = SerializeCompound<'a, 'b, W, N, D>;
fn serialize_bool(self, v: bool) -> Result<()> { fn serialize_bool(self, v: bool) -> Result<()> {
Ok(self.write.write_bool(v)?) Ok(self.write.write_bool(v)?)
@ -181,12 +177,12 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut
if name == crate::value::value::MAGIC_VALUE { if name == crate::value::value::MAGIC_VALUE {
let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) }; let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) };
let v: &Value<N, D> = *b; let v: &Value<N, D> = *b;
Encoder::new(&mut self.write, self.placeholders.as_ref()).write_value(v)?; Encoder::new(self.write, self.placeholders).write_value(v)?;
Ok(()) Ok(())
} else if name == crate::value::value::MAGIC_NESTEDVALUE { } else if name == crate::value::value::MAGIC_NESTEDVALUE {
let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &N) }; let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &N) };
let v: &N = *b; let v: &N = *b;
Encoder::new(&mut self.write, self.placeholders.as_ref()).write(v)?; Encoder::new(self.write, self.placeholders).write(v)?;
Ok(()) Ok(())
} else { } else {
// TODO: This is apparently discouraged, and we should apparently just serialize `value`? // TODO: This is apparently discouraged, and we should apparently just serialize `value`?
@ -271,7 +267,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -291,7 +287,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for S
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -309,7 +305,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct fo
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -327,7 +323,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVar
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -343,7 +339,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -359,7 +355,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStru
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -375,7 +371,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVari
} }
} }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, W, N, D> { impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W, N, D> {
type Ok = (); type Ok = ();
type Error = Error; type Error = Error;
@ -391,8 +387,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for S
} }
} }
pub fn to_writer<W: Writer, T: Serialize>(write: W, value: &T) -> Result<()> { pub fn to_writer<W: Writer, T: Serialize>(write: &mut W, value: &T) -> Result<()> {
let mut ser: Serializer<W, PlainValue<NullDomain>, NullDomain> = let mut ser: Serializer<'_, W, PlainValue<NullDomain>, NullDomain> = Serializer::new(write, None);
Serializer::without_placeholders(write);
value.serialize(&mut ser) value.serialize(&mut ser)
} }