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"
serde = { version = "1.0", features = ["derive"] }
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"));
let v_bytes_1 = Codec::new(placeholders.clone()).encode_bytes(&w).unwrap();
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!("== v bytes = {:?}", 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::{
Value, NestedValue, PlainValue,
Domain, NullDomain,
DecodePlaceholderMap, EncodePlaceholderMap, invert_map,
EncodePlaceholderMap,
Encoder,
};
@ -41,14 +41,14 @@ impl std::fmt::Display for Error {
impl std::error::Error for Error {}
#[derive(Debug)]
pub struct Serializer<W: Writer, N: NestedValue<D>, D: Domain> {
pub write: W,
placeholders: Option<EncodePlaceholderMap<N, D>>,
pub struct Serializer<'a, W: Writer, N: NestedValue<D>, D: Domain> {
pub write: &'a mut W,
placeholders: Option<&'a EncodePlaceholderMap<N, D>>,
}
impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
pub fn new(write: W, placeholders: &DecodePlaceholderMap<N, D>) -> Self {
Serializer { write, placeholders: Some(invert_map(&placeholders)) }
impl<'a, W: Writer, N: NestedValue<D>, D: Domain> Serializer<'a, W, N, D> {
pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap<N, D>>) -> Self {
Serializer { write, placeholders }
}
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)?),
}
}
pub fn without_placeholders(write: W) -> Self {
Serializer { write, placeholders: None }
}
}
#[derive(Debug)]
pub struct SerializeCompound<'a, W: Writer, N: NestedValue<D>, D: Domain> {
ser: &'a mut Serializer<W, N, D>,
pub struct SerializeCompound<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> {
ser: &'a mut Serializer<'b, W, N, D>,
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 Error = Error;
type SerializeSeq = SerializeCompound<'a, W, N, D>;
type SerializeTuple = SerializeCompound<'a, W, N, D>;
type SerializeTupleStruct = SerializeCompound<'a, W, N, D>;
type SerializeTupleVariant = SerializeCompound<'a, W, N, D>;
type SerializeMap = SerializeCompound<'a, W, N, D>;
type SerializeStruct = SerializeCompound<'a, W, N, D>;
type SerializeStructVariant = SerializeCompound<'a, W, N, D>;
type SerializeSeq = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTuple = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTupleStruct = SerializeCompound<'a, 'b, W, N, D>;
type SerializeTupleVariant = SerializeCompound<'a, 'b, W, N, D>;
type SerializeMap = SerializeCompound<'a, 'b, W, N, D>;
type SerializeStruct = SerializeCompound<'a, 'b, W, N, D>;
type SerializeStructVariant = SerializeCompound<'a, 'b, W, N, D>;
fn serialize_bool(self, v: bool) -> Result<()> {
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 {
let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) };
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(())
} 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 v: &N = *b;
Encoder::new(&mut self.write, self.placeholders.as_ref()).write(v)?;
Encoder::new(self.write, self.placeholders).write(v)?;
Ok(())
} else {
// 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 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 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 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 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 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 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 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<()> {
let mut ser: Serializer<W, PlainValue<NullDomain>, NullDomain> =
Serializer::without_placeholders(write);
pub fn to_writer<W: Writer, T: Serialize>(write: &mut W, value: &T) -> Result<()> {
let mut ser: Serializer<'_, W, PlainValue<NullDomain>, NullDomain> = Serializer::new(write, None);
value.serialize(&mut ser)
}