From dfc50fcaeeac36a6e2ab1344888eb126d6ad96dd Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Tue, 26 May 2020 11:01:33 +0200 Subject: [PATCH] Simplify code (and get back up to speed! ~150kHz) by insisting on IOValue for all codec operations --- implementations/rust/src/lib.rs | 64 ++++----- implementations/rust/src/ser.rs | 53 ++++--- implementations/rust/src/value/codec.rs | 25 ++-- implementations/rust/src/value/de.rs | 160 +++++++++++----------- implementations/rust/src/value/decoder.rs | 16 +-- implementations/rust/src/value/encoder.rs | 20 +-- implementations/rust/src/value/magic.rs | 17 +-- implementations/rust/src/value/mod.rs | 17 ++- implementations/rust/src/value/reader.rs | 60 ++++---- implementations/rust/src/value/ser.rs | 98 +++++++------ implementations/rust/src/value/value.rs | 114 +++++++++++---- 11 files changed, 331 insertions(+), 313 deletions(-) diff --git a/implementations/rust/src/lib.rs b/implementations/rust/src/lib.rs index c9f70cc..acc5413 100644 --- a/implementations/rust/src/lib.rs +++ b/implementations/rust/src/lib.rs @@ -6,7 +6,9 @@ pub mod value; #[cfg(test)] mod dom { - use super::value::{Value, PlainValue, NestedValue, Domain, Encoder, Codec, writer::Writer}; + use super::value::{ + Value, IOValue, NestedValue, PlainValue, Domain, Codec, + }; #[derive(Debug, Hash, Clone, Ord, PartialEq, Eq, PartialOrd)] pub enum Dom { @@ -15,22 +17,12 @@ mod dom { } impl Domain for Dom { - fn encode<'a, 'b, W: Writer, N: NestedValue>( - &self, enc: &mut Encoder<'a, 'b, W, N, Self>) -> - super::value::encoder::Result - { - match self { - Dom::One => { - enc.write.stream_bytes()?; - enc.write.write_bytes(&[255, 255, 255, 255])?; - enc.write.close_stream() - } - Dom::Two => enc.write(&self.as_preserves()?) - } - } - - fn as_preserves, D: Domain>(&self) -> Result { - Ok(Value::symbol(&format!("Dom::{:?}", self)).wrap()) + fn as_preserves(&self) -> Result { + Ok(match self { + // TODO: How to nicely expose streaming values? + Dom::One => Value::ByteString(vec![255, 255, 255, 255]).wrap(), + Dom::Two => Value::symbol(&format!("Dom::{:?}", self)).wrap(), + }) } } @@ -39,8 +31,8 @@ mod dom { Value::Domain(Dom::One).wrap(), Value::from(2).wrap()]) .wrap(); - assert_eq!(Codec::without_placeholders().encode_bytes(&v).unwrap(), - [147, 49, 38, 100, 255, 255, 255, 255, 4, 50]); + assert_eq!(Codec::without_placeholders().encode_bytes(&v.to_io_value()).unwrap(), + [147, 49, 100, 255, 255, 255, 255, 50]); } #[test] fn test_two() { @@ -48,7 +40,7 @@ mod dom { Value::Domain(Dom::Two).wrap(), Value::from(2).wrap()]) .wrap(); - assert_eq!(Codec::without_placeholders().encode_bytes(&v).unwrap(), + assert_eq!(Codec::without_placeholders().encode_bytes(&v.to_io_value()).unwrap(), [147, 49, 120, 68, 111, 109, 58, 58, 84, 119, 111, 50]); } } @@ -236,13 +228,12 @@ mod value_tests { #[cfg(test)] mod decoder_tests { use crate::value::{Decoder, BinaryReader}; - use crate::value::{Value, PlainValue, NestedValue}; - use super::dom::Dom; + use crate::value::{Value, NestedValue}; #[test] fn skip_annotations_noskip() { let mut buf = &b"\x0521"[..]; let r = BinaryReader::new(&mut buf); - let mut d = Decoder::<_, PlainValue, Dom>::new(r, None); + let mut d = Decoder::new(r, None); let v = d.next_or_err().unwrap(); assert_eq!(v.annotations().len(), 1); assert_eq!(v.annotations()[0], Value::from(2).wrap()); @@ -252,7 +243,7 @@ mod decoder_tests { #[test] fn skip_annotations_skip() { let mut buf = &b"\x0521"[..]; let r = BinaryReader::new(&mut buf); - let mut d = Decoder::<_, PlainValue, Dom>::new(r, None); + let mut d = Decoder::new(r, None); d.set_read_annotations(false); let v = d.next_or_err().unwrap(); assert_eq!(v.annotations().len(), 0); @@ -263,7 +254,7 @@ mod decoder_tests { let mut buf = &b"\x81tPing\x81tPong"[..]; assert_eq!(buf.len(), 12); let r = BinaryReader::new(&mut buf); - let mut d = Decoder::<_, PlainValue, Dom>::new(r, None); + let mut d = Decoder::new(r, None); assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![])); assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![])); assert_eq!(buf.len(), 0); @@ -273,11 +264,11 @@ mod decoder_tests { let mut buf = &b"\x81tPing\x81tPong"[..]; assert_eq!(buf.len(), 12); let mut r = BinaryReader::new(&mut buf); - let mut d = Decoder::<_, PlainValue, Dom>::new(&mut r, None); + let mut d = Decoder::new(&mut r, None); assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Ping", vec![])); assert_eq!(buf.len(), 6); let mut r = BinaryReader::new(&mut buf); - let mut d = Decoder::<_, PlainValue, Dom>::new(&mut r, None); + let mut d = Decoder::new(&mut r, None); assert_eq!(d.next_or_err().unwrap().value(), &Value::simple_record("Pong", vec![])); assert_eq!(buf.len(), 0); } @@ -288,14 +279,13 @@ mod samples_tests { use crate::symbol::Symbol; use crate::value::{Codec, Decoder, BinaryReader}; use crate::value::reader::is_syntax_error; - use crate::value::{Value, PlainValue, Map}; + use crate::value::{Value, IOValue, Map}; use crate::value::DecodePlaceholderMap; use crate::value::to_value; use crate::value::from_value; - use super::dom::Dom; #[derive(Debug, serde::Serialize, serde::Deserialize)] - struct ExpectedPlaceholderMapping(DecodePlaceholderMap, Dom>); + struct ExpectedPlaceholderMapping(DecodePlaceholderMap); #[derive(Debug, serde::Serialize, serde::Deserialize)] struct TestCases { @@ -305,10 +295,10 @@ mod samples_tests { #[derive(Debug, serde::Serialize, serde::Deserialize)] enum TestCase { - Test(#[serde(with = "serde_bytes")] Vec, PlainValue), - NondeterministicTest(#[serde(with = "serde_bytes")] Vec, PlainValue), - StreamingTest(#[serde(with = "serde_bytes")] Vec, PlainValue), - DecodeTest(#[serde(with = "serde_bytes")] Vec, PlainValue), + Test(#[serde(with = "serde_bytes")] Vec, IOValue), + NondeterministicTest(#[serde(with = "serde_bytes")] Vec, IOValue), + StreamingTest(#[serde(with = "serde_bytes")] Vec, IOValue), + DecodeTest(#[serde(with = "serde_bytes")] Vec, IOValue), ParseError(String), ParseShort(String), DecodeError(#[serde(with = "serde_bytes")] Vec), @@ -318,7 +308,7 @@ mod samples_tests { #[test] fn run() -> std::io::Result<()> { let mut fh = std::fs::File::open("../../tests/samples.bin").unwrap(); let r = BinaryReader::new(&mut fh); - let mut d = Decoder::<_, PlainValue, Dom>::new(r, None); + let mut d = Decoder::new(r, None); let tests: TestCases = from_value(&d.next_or_err().unwrap()).unwrap(); // println!("{:#?}", tests); @@ -380,7 +370,7 @@ mod samples_tests { #[serde(with = "serde_bytes")] &'a [u8], #[serde(with = "serde_bytes")] Vec, i16, - PlainValue); + IOValue); let v = SimpleValue("hello".to_string(), "sym1".to_string(), Symbol("sym2".to_string()), @@ -392,7 +382,7 @@ mod samples_tests { 12345, Value::from("hi").wrap()); println!("== v: {:#?}", v); - let w: PlainValue = to_value(&v); + let w: IOValue = to_value(&v); println!("== w: {:#?}", w); let x = from_value(&w).unwrap(); println!("== x: {:#?}", &x); diff --git a/implementations/rust/src/ser.rs b/implementations/rust/src/ser.rs index 580fe86..3c44771 100644 --- a/implementations/rust/src/ser.rs +++ b/implementations/rust/src/ser.rs @@ -1,23 +1,18 @@ use serde::Serialize; use super::value::writer::Writer; -use super::value::{ - Value, NestedValue, PlainValue, - Domain, NullDomain, - EncodePlaceholderMap, - Encoder, -}; +use super::value::{Value, EncodePlaceholderMap, Encoder}; pub use super::error::Error; type Result = std::result::Result; #[derive(Debug)] -pub struct Serializer<'a, W: Writer, N: NestedValue, D: Domain> { +pub struct Serializer<'a, W: Writer> { pub write: &'a mut W, - placeholders: Option<&'a EncodePlaceholderMap>, + placeholders: Option<&'a EncodePlaceholderMap>, } -impl<'a, W: Writer, N: NestedValue, D: Domain> Serializer<'a, W, N, D> { - pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap>) -> Self { +impl<'a, W: Writer> Serializer<'a, W> { + pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap>) -> Self { Serializer { write, placeholders } } @@ -30,21 +25,21 @@ impl<'a, W: Writer, N: NestedValue, D: Domain> Serializer<'a, W, N, D> { } #[derive(Debug)] -pub struct SerializeCompound<'a, 'b, W: Writer, N: NestedValue, D: Domain> { - ser: &'a mut Serializer<'b, W, N, D>, +pub struct SerializeCompound<'a, 'b, W: Writer> { + ser: &'a mut Serializer<'b, W>, count: Option, } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::Serializer for &'a mut Serializer<'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::Serializer for &'a mut Serializer<'b, W> { type Ok = (); type Error = Error; - 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>; + type SerializeSeq = SerializeCompound<'a, 'b, W>; + type SerializeTuple = SerializeCompound<'a, 'b, W>; + type SerializeTupleStruct = SerializeCompound<'a, 'b, W>; + type SerializeTupleVariant = SerializeCompound<'a, 'b, W>; + type SerializeMap = SerializeCompound<'a, 'b, W>; + type SerializeStruct = SerializeCompound<'a, 'b, W>; + type SerializeStructVariant = SerializeCompound<'a, 'b, W>; fn serialize_bool(self, v: bool) -> Result<()> { Ok(self.write.write_bool(v)?) @@ -146,7 +141,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::Serializer for &'a { match super::value::magic::receive_output_value(name, value) { Some(v) => { - Encoder::new(self.write, self.placeholders).write(&v.copy_via(&|_| unreachable!()))?; + Encoder::new(self.write, self.placeholders).write(&v)?; Ok(()) } None => { @@ -233,7 +228,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::Serializer for &'a } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -253,7 +248,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeMap f } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -271,7 +266,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeStruc } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -289,7 +284,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeStruc } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -305,7 +300,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTuple } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -321,7 +316,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTuple } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -337,7 +332,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeTuple } } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W, N, D> { +impl<'a, 'b, W: Writer> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W> { type Ok = (); type Error = Error; @@ -354,6 +349,6 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> serde::ser::SerializeSeq f } pub fn to_writer(write: &mut W, value: &T) -> Result<()> { - let mut ser: Serializer<'_, W, PlainValue, NullDomain> = Serializer::new(write, None); + let mut ser: Serializer<'_, W> = Serializer::new(write, None); value.serialize(&mut ser) } diff --git a/implementations/rust/src/value/codec.rs b/implementations/rust/src/value/codec.rs index 8e71bdb..0056a55 100644 --- a/implementations/rust/src/value/codec.rs +++ b/implementations/rust/src/value/codec.rs @@ -4,18 +4,16 @@ use super::{ encoder::{Encoder, EncodePlaceholderMap}, invert_map, reader::{BinaryReader, is_eof_error}, - value::{ - NestedValue, Domain, - }, + value::IOValue, }; -pub struct Codec, D: Domain> { - pub decode_placeholders: Option>, - pub encode_placeholders: Option>, +pub struct Codec { + pub decode_placeholders: Option, + pub encode_placeholders: Option, } -impl, D: Domain> Codec { - pub fn new(decode_placeholders: DecodePlaceholderMap) -> Self { +impl Codec { + pub fn new(decode_placeholders: DecodePlaceholderMap) -> Self { let encode_placeholders = Some(invert_map(&decode_placeholders)); Codec { decode_placeholders: Some(decode_placeholders), encode_placeholders } } @@ -24,17 +22,18 @@ impl, D: Domain> Codec { Codec { decode_placeholders: None, encode_placeholders: None } } - pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'a, BinaryReader<'r, R>, N, D> { + pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'a, BinaryReader<'r, R>> { Decoder::new(BinaryReader::new(read), self.decode_placeholders.as_ref()) } - pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W, N, D> { + pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W> { Encoder::new(write, self.encode_placeholders.as_ref()) } - pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result> { + pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result> { let mut r = BinaryReader::new(read); - let vs: Vec = Decoder::new(&mut r, self.decode_placeholders.as_ref()).collect::>>()?; + let vs: Vec = Decoder::new(&mut r, self.decode_placeholders.as_ref()) + .collect::>>()?; match r.peek() { Err(e) if is_eof_error(&e) => Ok(vs), Err(e) => Err(e), @@ -42,7 +41,7 @@ impl, D: Domain> Codec { } } - pub fn encode_bytes(&self, v: &N) -> std::io::Result> { + pub fn encode_bytes(&self, v: &IOValue) -> std::io::Result> { let mut buf: Vec = Vec::new(); self.encoder(&mut buf).write(v)?; Ok(buf) diff --git a/implementations/rust/src/value/de.rs b/implementations/rust/src/value/de.rs index f5706bc..e38329d 100644 --- a/implementations/rust/src/value/de.rs +++ b/implementations/rust/src/value/de.rs @@ -1,23 +1,22 @@ -use crate::value::{Value, NestedValue, Map, Domain}; +use crate::value::{Value, NestedValue, IOValue, UnwrappedIOValue, Map}; use crate::value::value::{Float, Double}; use num::traits::cast::ToPrimitive; use serde::Deserialize; use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed}; use std::convert::TryFrom; use std::iter::Iterator; -use std::marker::PhantomData; pub mod error { use num::bigint::BigInt; - use crate::value::{PlainValue, Domain}; + use crate::value::IOValue; #[derive(Debug)] - pub enum Error { + pub enum Error { Message(String), InvalidUnicodeScalar(u32), NumberTooLarge(BigInt), CannotDeserializeAny, - Expected(ExpectedKind, PlainValue), + Expected(ExpectedKind, IOValue), } #[derive(Debug)] @@ -38,15 +37,15 @@ pub mod error { Dictionary, } - impl serde::de::Error for Error { + impl serde::de::Error for Error { fn custom(msg: T) -> Self { Self::Message(msg.to_string()) } } - impl std::error::Error for Error {} + impl std::error::Error for Error {} - impl std::fmt::Display for Error { + impl std::fmt::Display for Error { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self) } @@ -56,39 +55,36 @@ pub mod error { pub use error::Error; use error::ExpectedKind; -pub type Result = std::result::Result>; +pub type Result = std::result::Result; -pub struct Deserializer<'de, N: NestedValue, D: Domain> { - input: &'de N, - phantom: PhantomData, +pub struct Deserializer<'de> { + input: &'de IOValue, } -pub fn from_value<'a, T, N: NestedValue, D: 'a + Domain>(v: &'a N) -> - Result where T: Deserialize<'a> +pub fn from_value<'a, T>(v: &'a IOValue) -> Result where T: Deserialize<'a> { let mut de = Deserializer::from_value(v); let t = T::deserialize(&mut de)?; Ok(t) } -impl<'de, N: NestedValue, D: 'de + Domain> Deserializer<'de, N, D> { - pub fn from_value(v: &'de N) -> Self { - Deserializer{ input: v, phantom: PhantomData } +impl<'de> Deserializer<'de> { + pub fn from_value(v: &'de IOValue) -> Self { + Deserializer { input: v } } - fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result - where F: FnOnce(&'de Value) -> Option + fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result + where F: FnOnce(&'de UnwrappedIOValue) -> Option { - f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via_id())) + f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.clone())) } } -impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> - for &'a mut Deserializer<'de, N, D> +impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de> { - type Error = Error; + type Error = Error; - fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de> { let v = self.input.value(); match v { @@ -123,70 +119,70 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } } - fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_bool(self.check(|v| v.as_boolean(), ExpectedKind::Boolean)?) } - fn deserialize_i8(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_i8(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_i16(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_i16(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_i32(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_i32(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_i64(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_i64(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_u8(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_u8(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_u16(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_u16(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_u32(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_u32(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_u64(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_u64(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } - fn deserialize_f32(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_f32(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_f32(self.check(|v| v.as_float(), ExpectedKind::Float)?) } - fn deserialize_f64(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_f64(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_f64(self.check(|v| v.as_double(), ExpectedKind::Double)?) } - fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de> { let fs = self.check(|v| v.as_simple_record("UnicodeScalar", Some(1)), ExpectedKind::SimpleRecord("UnicodeScalar", Some(1)))?; @@ -195,27 +191,27 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?) } - fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_borrowed_str(&self.check(|v| v.as_string(), ExpectedKind::String)?) } - fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de> { self.deserialize_str(visitor) } - fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_borrowed_bytes(&self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?) } - fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_byte_buf(self.check(|v| v.as_bytestring(), ExpectedKind::ByteString)?.clone()) } - fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de> { match self.input.value().as_simple_record("None", Some(0)) { Some(_fs) => visitor.visit_none(), @@ -229,7 +225,7 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } } - fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de> { if self.input.value().is_simple_record("tuple", Some(0)) { visitor.visit_unit() @@ -239,7 +235,7 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } fn deserialize_unit_struct(self, name: &'static str, visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { if self.input.value().is_simple_record(name, Some(0)) { visitor.visit_unit() @@ -249,9 +245,9 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } fn deserialize_newtype_struct(self, name: &'static str, visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { - match super::magic::transmit_input_value(name, || self.input.copy_to_null_domain()) { + match super::magic::transmit_input_value(name, || self.input.clone()) { Some(v) => visitor.visit_u64(v), None => { let fs = self.check(|v| v.as_simple_record(name, Some(1)), @@ -262,12 +258,12 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } } - fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de> { + fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de> { let vs = self.check(|v| v.as_sequence(), ExpectedKind::Sequence)?; visitor.visit_seq(VecSeq::new(self, vs)) } - fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: Visitor<'de> { let fs = self.check(|v| v.as_simple_record("tuple", Some(len)), ExpectedKind::SimpleRecord("tuple", Some(len)))?; @@ -275,14 +271,14 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> } fn deserialize_tuple_struct(self, name: &'static str, len: usize, visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { let fs = self.check(|v| v.as_simple_record(name, Some(len)), ExpectedKind::SimpleRecord(name, Some(len)))?; visitor.visit_seq(VecSeq::new(self, fs)) } - fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de> { + fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de> { let d = self.check(|v| v.as_dictionary(), ExpectedKind::Dictionary)?; visitor.visit_map(DictMap::new(self, d)) } @@ -291,7 +287,7 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> name: &'static str, fields: &'static [&'static str], visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { let fs = self.check(|v| v.as_simple_record(name, Some(fields.len())), ExpectedKind::SimpleRecord(name, Some(fields.len())))?; @@ -302,39 +298,39 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> serde::de::Deserializer<'de> _name: &'static str, _variants: &'static [&'static str], visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { visitor.visit_enum(self) } - fn deserialize_identifier(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_identifier(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_borrowed_str(&self.check(|v| v.as_symbol(), ExpectedKind::Symbol)?) } - fn deserialize_ignored_any(self, visitor: V) -> Result where V: Visitor<'de> + fn deserialize_ignored_any(self, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_none() } } -pub struct VecSeq<'a, 'de: 'a, N: NestedValue, D: Domain> { +pub struct VecSeq<'a, 'de: 'a> { index: usize, - vec: &'de [N], - de: &'a mut Deserializer<'de, N, D>, + vec: &'de [IOValue], + de: &'a mut Deserializer<'de>, } -impl<'de, 'a, N: NestedValue, D: Domain> VecSeq<'a, 'de, N, D> { - fn new(de: &'a mut Deserializer<'de, N, D>, vec: &'de [N]) -> Self { - VecSeq{ index: 0, vec, de } +impl<'de, 'a> VecSeq<'a, 'de> { + fn new(de: &'a mut Deserializer<'de>, vec: &'de [IOValue]) -> Self { + VecSeq { index: 0, vec, de } } } -impl<'de, 'a, N: NestedValue, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a, 'de, N, D> { - type Error = Error; +impl<'de, 'a> SeqAccess<'de> for VecSeq<'a, 'de> { + type Error = Error; fn next_element_seed(&mut self, seed: T) - -> Result, D> where T: DeserializeSeed<'de> + -> Result> where T: DeserializeSeed<'de> { if self.index == self.vec.len() { return Ok(None) @@ -347,23 +343,23 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> SeqAccess<'de> for VecSeq<'a, } } -pub struct DictMap<'a, 'de: 'a, N: NestedValue, D: Domain> { - pending: Option<&'de N>, - iter: Box + 'a>, - de: &'a mut Deserializer<'de, N, D>, +pub struct DictMap<'a, 'de: 'a> { + pending: Option<&'de IOValue>, + iter: Box + 'a>, + de: &'a mut Deserializer<'de>, } -impl<'de, 'a, N: NestedValue, D: Domain> DictMap<'a, 'de, N, D> { - fn new(de: &'a mut Deserializer<'de, N, D>, d: &'de Map) -> Self { +impl<'de, 'a> DictMap<'a, 'de> { + fn new(de: &'a mut Deserializer<'de>, d: &'de Map) -> Self { DictMap{ pending: None, iter: Box::new(d.iter()), de } } } -impl<'de, 'a, N: NestedValue, D: 'de + Domain> MapAccess<'de> for DictMap<'a, 'de, N, D> { - type Error = Error; +impl<'de, 'a> MapAccess<'de> for DictMap<'a, 'de> { + type Error = Error; fn next_key_seed(&mut self, seed: K) - -> Result, D> where K: DeserializeSeed<'de> + -> Result> where K: DeserializeSeed<'de> { match self.iter.next() { None => Ok(None), @@ -375,7 +371,7 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> MapAccess<'de> for DictMap<'a, } } - fn next_value_seed(&mut self, seed: V) -> Result where V: DeserializeSeed<'de> { + fn next_value_seed(&mut self, seed: V) -> Result where V: DeserializeSeed<'de> { let v = self.pending.unwrap(); self.pending = None; self.de.input = v; @@ -383,41 +379,41 @@ impl<'de, 'a, N: NestedValue, D: 'de + Domain> MapAccess<'de> for DictMap<'a, } } -impl<'a, 'de, N: NestedValue, D: 'de + Domain> EnumAccess<'de> for &'a mut Deserializer<'de, N, D> { - type Error = Error; +impl<'a, 'de> EnumAccess<'de> for &'a mut Deserializer<'de> { + type Error = Error; type Variant = Self; fn variant_seed(self, seed: V) - -> Result<(V::Value, Self::Variant), D> where V: DeserializeSeed<'de> + -> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de> { let (lp, _) = self.check(|v| v.as_record(None), ExpectedKind::Record(None))?; let v = self.input; - self.input = N::boxunwrap(lp); + self.input = IOValue::boxunwrap(lp); let variant = seed.deserialize(&mut *self)?; self.input = v; Ok((variant, self)) } } -impl<'a, 'de, N: NestedValue, D: 'de + Domain> VariantAccess<'de> for &'a mut Deserializer<'de, N, D> { - type Error = Error; +impl<'a, 'de> VariantAccess<'de> for &'a mut Deserializer<'de> { + type Error = Error; - fn unit_variant(self) -> Result<(), D> { + fn unit_variant(self) -> Result<()> { Ok(()) } - fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de> { + fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de> { let (_, fs) = self.check(|v| v.as_record(Some(1)), ExpectedKind::Record(Some(1)))?; self.input = &fs[0]; seed.deserialize(&mut *self) } - fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: Visitor<'de> { + fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: Visitor<'de> { visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(None).unwrap().1)) } fn struct_variant(self, fields: &'static [&'static str], visitor: V) - -> Result where V: Visitor<'de> + -> Result where V: Visitor<'de> { visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record(Some(fields.len())).unwrap().1)) } diff --git a/implementations/rust/src/value/decoder.rs b/implementations/rust/src/value/decoder.rs index 5d9a4e9..ba4ae48 100644 --- a/implementations/rust/src/value/decoder.rs +++ b/implementations/rust/src/value/decoder.rs @@ -1,16 +1,16 @@ use super::reader::{Reader, is_eof_error}; -use super::value::{NestedValue, Domain}; +use super::value::IOValue; pub use super::reader::{Result, DecodePlaceholderMap}; -pub struct Decoder<'a, R: Reader, N: NestedValue, Dom: Domain> { +pub struct Decoder<'a, R: Reader> { pub read: R, - placeholders: Option<&'a DecodePlaceholderMap>, + placeholders: Option<&'a DecodePlaceholderMap>, read_annotations: bool, } -impl<'a, R: Reader, N: NestedValue, D: Domain> Decoder<'a, R, N, D> { - pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap>) -> +impl<'a, R: Reader> Decoder<'a, R> { + pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap>) -> Self { Decoder { @@ -24,13 +24,13 @@ impl<'a, R: Reader, N: NestedValue, D: Domain> Decoder<'a, R, N, D> { self.read_annotations = read_annotations } - pub fn next_or_err(&mut self) -> Result { + pub fn next_or_err(&mut self) -> Result { self.read.next(self.placeholders, self.read_annotations) } } -impl<'a, R: Reader, N: NestedValue, D: Domain> std::iter::Iterator for Decoder<'a, R, N, D> { - type Item = Result; +impl<'a, R: Reader> std::iter::Iterator for Decoder<'a, R> { + type Item = Result; fn next(&mut self) -> Option { match self.next_or_err() { Err(e) if is_eof_error(&e) => None, diff --git a/implementations/rust/src/value/encoder.rs b/implementations/rust/src/value/encoder.rs index 3cc716e..b666b79 100644 --- a/implementations/rust/src/value/encoder.rs +++ b/implementations/rust/src/value/encoder.rs @@ -1,21 +1,21 @@ -use super::value::{Value, NestedValue, Float, Double, Map, Domain}; +use super::value::{Value, NestedValue, Domain, IOValue, UnwrappedIOValue, Float, Double, Map}; use super::writer::Writer; pub use super::writer::Result; -pub type EncodePlaceholderMap = Map, usize>; +pub type EncodePlaceholderMap = Map; -pub struct Encoder<'a, 'b, W: Writer, N: NestedValue, D: Domain> { +pub struct Encoder<'a, 'b, W: Writer> { pub write: &'a mut W, - pub placeholders: Option<&'b EncodePlaceholderMap>, + pub placeholders: Option<&'b EncodePlaceholderMap>, } -impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> Encoder<'a, 'b, W, N, D> { - pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap>) -> Self { +impl<'a, 'b, W: Writer> Encoder<'a, 'b, W> { + pub fn new(write: &'a mut W, placeholders: Option<&'b EncodePlaceholderMap>) -> Self { Encoder{ write, placeholders } } - pub fn write(&mut self, v: &N) -> Result { + pub fn write(&mut self, v: &IOValue) -> Result { for ann in v.annotations() { self.write.write_annotation_prefix()?; self.write(ann)?; @@ -23,7 +23,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> Encoder<'a, 'b, W, N, D> { self.write_value(v.value()) } - pub fn write_value(&mut self, v: &Value) -> Result { + pub fn write_value(&mut self, v: &UnwrappedIOValue) -> Result { match self.placeholders.and_then(|m| m.get(v)) { Some(&n) => self.write.write_placeholder_ref(n), None => match v { @@ -36,7 +36,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> Encoder<'a, 'b, W, N, D> { Value::Symbol(ref s) => self.write.write_symbol(s), Value::Record((ref l, ref fs)) => { self.write.open_record(fs.len())?; - self.write(N::boxunwrap(l))?; + self.write(IOValue::boxunwrap(l))?; for f in fs { self.write(f)?; } self.write.close_record() } @@ -55,7 +55,7 @@ impl<'a, 'b, W: Writer, N: NestedValue, D: Domain> Encoder<'a, 'b, W, N, D> { for (k, v) in vs { self.write(k)?; self.write(v)?; } self.write.close_dictionary() } - Value::Domain(ref d) => d.encode(self), + Value::Domain(ref d) => self.write(&d.as_preserves()?) } } } diff --git a/implementations/rust/src/value/magic.rs b/implementations/rust/src/value/magic.rs index dbca66b..bafbf34 100644 --- a/implementations/rust/src/value/magic.rs +++ b/implementations/rust/src/value/magic.rs @@ -1,16 +1,9 @@ -use super::{ - NullDomain, - value::{ - ArcValue, - NestedValue, - Domain, - }, +use super::value::{ + IOValue, }; pub static MAGIC: &str = "$____Preserves_Serde_Magic"; -pub type IOValue = ArcValue; - struct IOValueVisitor; impl<'de> serde::de::Visitor<'de> for IOValueVisitor { type Value = IOValue; @@ -35,12 +28,6 @@ pub fn input_value<'de, D: serde::Deserializer<'de>>(deserializer: D) -> deserializer.deserialize_newtype_struct(MAGIC, IOValueVisitor) } -pub fn input_value_via<'de, D: serde::Deserializer<'de>, N: NestedValue, Dom: Domain>(deserializer: D) -> - Result -{ - Ok(input_value(deserializer)?.copy_via(&|_| unreachable!())) -} - //--------------------------------------------------------------------------- pub fn receive_output_value(name: &'static str, magic_value: &T) -> Option { diff --git a/implementations/rust/src/value/mod.rs b/implementations/rust/src/value/mod.rs index f810831..b437198 100644 --- a/implementations/rust/src/value/mod.rs +++ b/implementations/rust/src/value/mod.rs @@ -23,15 +23,18 @@ pub use reader::is_eof_error; pub use reader::is_syntax_error; pub use ser::Serializer; pub use ser::to_value; -pub use value::Domain; -pub use value::NestedValue; -pub use value::Value; pub use value::AnnotatedValue; +pub use value::ArcValue; +pub use value::Domain; +pub use value::IOValue; +pub use value::Map; +pub use value::NestedValue; +pub use value::NullDomain; pub use value::PlainValue; pub use value::RcValue; -pub use value::ArcValue; pub use value::Set; -pub use value::Map; +pub use value::UnwrappedIOValue; +pub use value::Value; pub use writer::Writer; pub fn invert_map(m: &Map) -> Map @@ -40,7 +43,3 @@ pub fn invert_map(m: &Map) -> Map use std::iter::FromIterator; Map::from_iter(m.iter().map(|(a, b)| (b.clone(), a.clone()))) } - -#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub enum NullDomain {} -impl Domain for NullDomain {} diff --git a/implementations/rust/src/value/reader.rs b/implementations/rust/src/value/reader.rs index e270def..a1f9799 100644 --- a/implementations/rust/src/value/reader.rs +++ b/implementations/rust/src/value/reader.rs @@ -3,7 +3,7 @@ use std::convert::TryFrom; use std::convert::TryInto; use std::io::{Read, Error}; use super::constants::{Op, InvalidOp, AtomMinor, CompoundMinor}; -use super::value::{Value, Domain, NestedValue, Map, Set}; +use super::value::{Value, NestedValue, IOValue, UnwrappedIOValue, Map, Set}; pub type Result = std::result::Result; @@ -14,22 +14,22 @@ enum PeekState { Full(u8), } -pub type DecodePlaceholderMap = Map>; +pub type DecodePlaceholderMap = Map; pub trait Reader { - fn next, Dom: Domain>( + fn next( &mut self, - placeholders: Option<&DecodePlaceholderMap>, + placeholders: Option<&DecodePlaceholderMap>, read_annotations: bool, - ) -> Result; + ) -> Result; } impl<'re, R: Reader> Reader for &'re mut R { - fn next, Dom: Domain>( + fn next( &mut self, - placeholders: Option<&DecodePlaceholderMap>, + placeholders: Option<&DecodePlaceholderMap>, read_annotations: bool, - ) -> Result { + ) -> Result { (*self).next(placeholders, read_annotations) } } @@ -39,21 +39,20 @@ pub struct BinaryReader<'a, R: Read> { buf: PeekState, } -struct ConfiguredBinaryReader<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> { +struct ConfiguredBinaryReader<'de, 'pl, 'a, R: Read> { reader: &'de mut BinaryReader<'a, R>, - placeholders: Option<&'pl DecodePlaceholderMap>, + placeholders: Option<&'pl DecodePlaceholderMap>, read_annotations: bool, } -struct CountedStream<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> { - reader: ConfiguredBinaryReader<'de, 'pl, 'a, R, N, Dom>, +struct CountedStream<'de, 'pl, 'a, R: Read> { + reader: ConfiguredBinaryReader<'de, 'pl, 'a, R>, count: usize, } -impl<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> Iterator - for CountedStream<'de, 'pl, 'a, R, N, Dom> +impl<'de, 'pl, 'a, R: Read> Iterator for CountedStream<'de, 'pl, 'a, R> { - type Item = Result; + type Item = Result; fn next(&mut self) -> Option { if self.count == 0 { return None } self.count -= 1; @@ -61,14 +60,13 @@ impl<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> Iterator } } -struct DelimitedStream<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> { - reader: ConfiguredBinaryReader<'de, 'pl, 'a, R, N, Dom>, +struct DelimitedStream<'de, 'pl, 'a, R: Read> { + reader: ConfiguredBinaryReader<'de, 'pl, 'a, R>, } -impl<'de, 'pl, 'a, R: Read, N: NestedValue, Dom: Domain> Iterator - for DelimitedStream<'de, 'pl, 'a, R, N, Dom> +impl<'de, 'pl, 'a, R: Read> Iterator for DelimitedStream<'de, 'pl, 'a, R> { - type Item = Result; + type Item = Result; fn next(&mut self) -> Option { match self.reader.reader.peekend() { Err(e) => Some(Err(e)), @@ -90,7 +88,7 @@ pub fn decodestr(bs: &[u8]) -> Result<&str> { std::str::from_utf8(bs).map_err(|_| err("Invalid UTF-8")) } -pub fn decodebinary, Dom: Domain>(minor: AtomMinor, bs: Vec) -> Result { +pub fn decodebinary(minor: AtomMinor, bs: Vec) -> Result { match minor { AtomMinor::SignedInteger => Ok(Value::from(decodeint(&bs)).wrap()), AtomMinor::String => Ok(Value::from(decodestr(&bs)?).wrap()), @@ -99,12 +97,8 @@ pub fn decodebinary, Dom: Domain>(minor: AtomMinor, bs: Vec< } } - -pub fn decodecompound, Dom: Domain, I: Iterator>>( - minor: CompoundMinor, - mut iter: I, -) -> - Result +pub fn decodecompound>>(minor: CompoundMinor, mut iter: I) -> + Result { match minor { CompoundMinor::Record => @@ -112,11 +106,11 @@ pub fn decodecompound, Dom: Domain, I: Iterator Err(err("Too few elements in encoded record")), Some(labelres) => { let label = labelres?; - Ok(Value::record(label, iter.collect::>>()?).wrap()) + Ok(Value::record(label, iter.collect::>>()?).wrap()) } } CompoundMinor::Sequence => { - Ok(Value::Sequence(iter.collect::>>()?).wrap()) + Ok(Value::Sequence(iter.collect::>>()?).wrap()) } CompoundMinor::Set => { let mut s = Set::new(); @@ -244,12 +238,12 @@ impl<'a, R: Read> BinaryReader<'a, R> { } impl<'re, 'a, R: Read> Reader for BinaryReader<'a, R> { - fn next, Dom: Domain>( + fn next( &mut self, - placeholders: Option<&DecodePlaceholderMap>, + placeholders: Option<&DecodePlaceholderMap>, read_annotations: bool ) -> - Result + Result { loop { return match decodeop(self.read()?)? { @@ -274,7 +268,7 @@ impl<'re, 'a, R: Read> Reader for BinaryReader<'a, R> { } let v = self.next(placeholders, read_annotations)?; assert!(v.annotations().is_empty()); - Ok(N::wrap_ann(annotations, v.value_owned())) + Ok(IOValue::wrap_ann(annotations, v.value_owned())) } else { let _ = self.next(placeholders, read_annotations)?; continue; diff --git a/implementations/rust/src/value/ser.rs b/implementations/rust/src/value/ser.rs index 1834ab9..de4f8ee 100644 --- a/implementations/rust/src/value/ser.rs +++ b/implementations/rust/src/value/ser.rs @@ -1,6 +1,5 @@ -use crate::value::{Value, NestedValue, Map, Domain}; +use crate::value::{Value, Map, IOValue}; use serde::Serialize; -use std::marker::PhantomData; #[derive(Debug)] pub enum Error {} @@ -18,37 +17,32 @@ impl std::fmt::Display for Error { type Result = std::result::Result; -pub struct Serializer, D: Domain> { - phantom: PhantomData<(N, D)>, +pub struct Serializer; + +pub struct SerializeDictionary { + next_key: Option, + items: Map, } -pub struct SerializeDictionary, D: Domain> { - next_key: Option, - items: Map, - phantom: PhantomData, -} - -pub struct SerializeRecord, D: Domain> { +pub struct SerializeRecord { name: &'static str, - vec: Vec, - phantom: PhantomData, + vec: Vec, } -pub struct SerializeSequence, D: Domain> { - vec: Vec, - phantom: PhantomData, +pub struct SerializeSequence { + vec: Vec, } -impl, D: Domain> serde::Serializer for Serializer { - type Ok = N; +impl serde::Serializer for Serializer { + type Ok = IOValue; type Error = Error; - type SerializeSeq = SerializeSequence; - type SerializeTuple = SerializeRecord; - type SerializeTupleStruct = SerializeRecord; - type SerializeTupleVariant = SerializeRecord; - type SerializeMap = SerializeDictionary; - type SerializeStruct = SerializeRecord; - type SerializeStructVariant = SerializeRecord; + type SerializeSeq = SerializeSequence; + type SerializeTuple = SerializeRecord; + type SerializeTupleStruct = SerializeRecord; + type SerializeTupleVariant = SerializeRecord; + type SerializeMap = SerializeDictionary; + type SerializeStruct = SerializeRecord; + type SerializeStructVariant = SerializeRecord; fn serialize_bool(self, v: bool) -> Result { Ok(Value::from(v).wrap()) @@ -135,7 +129,7 @@ impl, D: Domain> serde::Serializer for Serializer { Result where T: Serialize { match super::magic::receive_output_value(name, value) { - Some(v) => Ok(v.copy_via(&|_| unreachable!())), + Some(v) => Ok(v), None => { // TODO: This is apparently discouraged, and we should apparently just serialize `value`? Ok(Value::simple_record(name, vec![to_value(value)]).wrap()) @@ -155,17 +149,17 @@ impl, D: Domain> serde::Serializer for Serializer { fn serialize_seq(self, count: Option) -> Result { let vec = match count { Some(n) => Vec::with_capacity(n), None => Vec::new() }; - Ok(SerializeSequence{ vec, phantom: PhantomData }) + Ok(SerializeSequence { vec }) } fn serialize_tuple(self, count: usize) -> Result { - Ok(SerializeRecord{ name: "tuple", vec: Vec::with_capacity(count), phantom: PhantomData }) + Ok(SerializeRecord { name: "tuple", vec: Vec::with_capacity(count) }) } fn serialize_tuple_struct(self, name: &'static str, count: usize) -> Result { - Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData }) + Ok(SerializeRecord { name, vec: Vec::with_capacity(count) }) } fn serialize_tuple_variant(self, @@ -175,15 +169,15 @@ impl, D: Domain> serde::Serializer for Serializer { count: usize) -> Result { - Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData }) + Ok(SerializeRecord { name: variant_name, vec: Vec::with_capacity(count) }) } fn serialize_map(self, _count: Option) -> Result { - Ok(SerializeDictionary{ next_key: None, items: Map::new(), phantom: PhantomData }) + Ok(SerializeDictionary { next_key: None, items: Map::new() }) } fn serialize_struct(self, name: &'static str, count: usize) -> Result { - Ok(SerializeRecord{ name, vec: Vec::with_capacity(count), phantom: PhantomData }) + Ok(SerializeRecord { name, vec: Vec::with_capacity(count) }) } fn serialize_struct_variant(self, @@ -193,12 +187,12 @@ impl, D: Domain> serde::Serializer for Serializer { count: usize) -> Result { - Ok(SerializeRecord{ name: variant_name, vec: Vec::with_capacity(count), phantom: PhantomData }) + Ok(SerializeRecord { name: variant_name, vec: Vec::with_capacity(count) }) } } -impl, D: Domain> serde::ser::SerializeMap for SerializeDictionary { - type Ok = N; +impl serde::ser::SerializeMap for SerializeDictionary { + type Ok = IOValue; type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<()> where T: Serialize { @@ -217,19 +211,19 @@ impl, D: Domain> serde::ser::SerializeMap for SerializeDiction } } -impl, D: Domain> SerializeRecord { - fn push(&mut self, value: N) -> Result<()> { +impl SerializeRecord { + fn push(&mut self, value: IOValue) -> Result<()> { self.vec.push(value); Ok(()) } - fn finish(self) -> Result { + fn finish(self) -> Result { Ok(Value::simple_record(self.name, self.vec).wrap()) } } -impl, D: Domain> serde::ser::SerializeStruct for SerializeRecord { - type Ok = N; +impl serde::ser::SerializeStruct for SerializeRecord { + type Ok = IOValue; type Error = Error; fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> @@ -243,8 +237,8 @@ impl, D: Domain> serde::ser::SerializeStruct for SerializeReco } } -impl, D: Domain> serde::ser::SerializeStructVariant for SerializeRecord { - type Ok = N; +impl serde::ser::SerializeStructVariant for SerializeRecord { + type Ok = IOValue; type Error = Error; fn serialize_field(&mut self, _name: &'static str, value: &T) -> Result<()> @@ -258,8 +252,8 @@ impl, D: Domain> serde::ser::SerializeStructVariant for Serial } } -impl, D: Domain> serde::ser::SerializeTuple for SerializeRecord { - type Ok = N; +impl serde::ser::SerializeTuple for SerializeRecord { + type Ok = IOValue; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -271,8 +265,8 @@ impl, D: Domain> serde::ser::SerializeTuple for SerializeRecor } } -impl, D: Domain> serde::ser::SerializeTupleStruct for SerializeRecord { - type Ok = N; +impl serde::ser::SerializeTupleStruct for SerializeRecord { + type Ok = IOValue; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -284,8 +278,8 @@ impl, D: Domain> serde::ser::SerializeTupleStruct for Serializ } } -impl, D: Domain> serde::ser::SerializeTupleVariant for SerializeRecord { - type Ok = N; +impl serde::ser::SerializeTupleVariant for SerializeRecord { + type Ok = IOValue; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -297,8 +291,8 @@ impl, D: Domain> serde::ser::SerializeTupleVariant for Seriali } } -impl, D: Domain> serde::ser::SerializeSeq for SerializeSequence { - type Ok = N; +impl serde::ser::SerializeSeq for SerializeSequence { + type Ok = IOValue; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize { @@ -311,6 +305,6 @@ impl, D: Domain> serde::ser::SerializeSeq for SerializeSequenc } } -pub fn to_value(value: T) -> N where T: Serialize, N: NestedValue { - value.serialize(Serializer{ phantom: PhantomData }).unwrap() +pub fn to_value(value: T) -> IOValue where T: Serialize { + value.serialize(Serializer).unwrap() } diff --git a/implementations/rust/src/value/value.rs b/implementations/rust/src/value/value.rs index 9b208ac..6fd2ca3 100644 --- a/implementations/rust/src/value/value.rs +++ b/implementations/rust/src/value/value.rs @@ -1,25 +1,18 @@ -use std::hash::{Hash,Hasher}; +use num::bigint::BigInt; +use num::traits::cast::ToPrimitive; use std::cmp::{Ordering}; use std::fmt::Debug; -use num::bigint::BigInt; -use std::vec::Vec; -use std::string::String; +use std::hash::{Hash,Hasher}; use std::ops::Index; use std::ops::IndexMut; -use num::traits::cast::ToPrimitive; +use std::string::String; +use std::vec::Vec; pub use std::collections::BTreeSet as Set; pub use std::collections::BTreeMap as Map; pub trait Domain: Sized + Debug + Clone + Eq + Hash + Ord { - fn encode<'a, 'b, W: super::writer::Writer, N: NestedValue>( - &self, enc: &mut super::encoder::Encoder<'a, 'b, W, N, Self>) -> - super::encoder::Result - { - enc.write(&self.as_preserves()?) - } - - fn as_preserves, D: Domain>(&self) -> Result { + fn as_preserves(&self) -> Result { Err(std::io::Error::new(std::io::ErrorKind::InvalidData, format!("Cannot Preserves-encode domain-specific value {:?}", self))) @@ -58,8 +51,12 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { self.copy_via(&|d| Value::Domain(d.clone())) } - fn copy_to_null_domain>(&self) -> M { - self.copy_via(&|d| d.as_preserves::().unwrap().value_owned()) + fn to_io_value(&self) -> IOValue { + self.copy_via(&|d| d.as_preserves().unwrap().value().clone()) + } + + fn from_io_value(v: &IOValue) -> Self { + v.copy_via(&|_| unreachable!()) } } @@ -537,10 +534,6 @@ impl, D: Domain> Value { Value::Domain(d) => f(d), } } - - pub fn copy_to_null_domain>(&self) -> Value { - self.copy_via(&|d| d.as_preserves::().unwrap().value_owned()) - } } impl, D: Domain> Index for Value { @@ -568,28 +561,28 @@ impl, D: Domain> Index<&N> for Value { //--------------------------------------------------------------------------- // This part is a terrible hack -impl, D: Domain> serde::Serialize for Value { +impl serde::Serialize for UnwrappedIOValue { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - super::magic::output_value(serializer, self.copy_to_null_domain().wrap()) + super::magic::output_value(serializer, self.clone().wrap()) } } -impl<'de, N: NestedValue, Dom: Domain> serde::Deserialize<'de> for Value { +impl<'de> serde::Deserialize<'de> for UnwrappedIOValue { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - Ok(super::magic::input_value_via::<'de, D, N, Dom>(deserializer)?.value_owned()) + Ok(super::magic::input_value::<'de, D>(deserializer)?.value_owned()) } } pub fn serialize_nested_value(v: &N, serializer: S) -> Result where S: serde::Serializer, N: NestedValue + serde::Serialize { - super::magic::output_value(serializer, v.copy_to_null_domain()) + super::magic::output_value(serializer, v.to_io_value()) } pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) -> Result where D: serde::Deserializer<'de>, N: NestedValue + serde::Deserialize<'de> { - super::magic::input_value_via(deserializer) + Ok(N::from_io_value(&super::magic::input_value(deserializer)?)) } //--------------------------------------------------------------------------- @@ -803,3 +796,74 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue { deserialize_nested_value(deserializer) } } + +//--------------------------------------------------------------------------- + +#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub enum NullDomain {} +impl Domain for NullDomain {} + +#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct IOValue(Arc>); +pub type UnwrappedIOValue = Value; + +impl NestedValue for IOValue { + type BoxType = Self; + + fn wrap(v: Value) -> Self { + Self::wrap_ann(Vec::new(), v) + } + + fn wrap_ann(anns: Vec, v: Value) -> Self { + IOValue(Arc::new(AnnotatedValue(anns, v))) + } + + fn boxwrap(self) -> Self::BoxType { + self + } + + fn boxunwrap(b: &Self::BoxType) -> &Self { + b + } + + fn annotations(&self) -> &[Self] { + &(self.0).0 + } + + fn value(&self) -> &Value { + &(self.0).1 + } + + fn value_owned(self) -> Value { + match Arc::try_unwrap(self.0) { + Ok(AnnotatedValue(_anns, v)) => v, + Err(r) => r.1.clone(), + } + } + + fn to_io_value(&self) -> IOValue { + self.clone() + } + + fn from_io_value(v: &IOValue) -> Self { + v.clone() + } +} + +impl Debug for IOValue { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.debug_fmt(f) + } +} + +impl serde::Serialize for IOValue { + fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { + serialize_nested_value(self, serializer) + } +} + +impl<'de> serde::Deserialize<'de> for IOValue { + fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { + deserialize_nested_value(deserializer) + } +}