From 8cdd67f5ba452864492585ff48847c2fab29b38e Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Fri, 20 Sep 2019 21:42:09 +0100 Subject: [PATCH] Mutable Read in Decoder --- implementations/rust/src/lib.rs | 28 +++++++++++++---------- implementations/rust/src/value/codec.rs | 4 ++-- implementations/rust/src/value/decoder.rs | 20 ++++++++-------- implementations/rust/src/value/ser.rs | 4 ++-- implementations/rust/src/value/value.rs | 4 ++-- 5 files changed, 32 insertions(+), 28 deletions(-) diff --git a/implementations/rust/src/lib.rs b/implementations/rust/src/lib.rs index 561e0f1..4d7af3d 100644 --- a/implementations/rust/src/lib.rs +++ b/implementations/rust/src/lib.rs @@ -180,7 +180,8 @@ mod decoder_tests { use crate::value::Value; #[test] fn read_123() { - let mut d = Decoder::new(&b"abc"[..], None); + let mut buf = &b"abc"[..]; + let mut d = Decoder::new(&mut buf, None); assert_eq!(d.read().ok(), Some(97)); assert_eq!(d.read().ok(), Some(98)); assert_eq!(d.read().ok(), Some(99)); @@ -188,7 +189,8 @@ mod decoder_tests { } #[test] fn skip_annotations_noskip() { - let mut d = Decoder::new(&b"\x0521"[..], None); + let mut buf = &b"\x0521"[..]; + let mut d = Decoder::new(&mut buf, None); let v = d.next().unwrap(); assert_eq!(v.annotations().len(), 1); assert_eq!(v.annotations()[0], Value::from(2).wrap()); @@ -196,7 +198,8 @@ mod decoder_tests { } #[test] fn skip_annotations_skip() { - let mut d = Decoder::new(&b"\x0521"[..], None); + let mut buf = &b"\x0521"[..]; + let mut d = Decoder::new(&mut buf, None); d.set_read_annotations(false); let v = d.next().unwrap(); assert_eq!(v.annotations().len(), 0); @@ -235,7 +238,8 @@ mod samples_tests { } #[test] fn run() -> codec::Result<()> { - let mut d = Decoder::new(std::fs::File::open("../../tests/samples.bin").unwrap(), None); + let mut fh = std::fs::File::open("../../tests/samples.bin").unwrap(); + let mut d = Decoder::new(&mut fh, None); let tests: TestCases = from_value(&d.next().unwrap()).unwrap(); // println!("{:#?}", tests); @@ -244,8 +248,8 @@ mod samples_tests { println!("{:?} ==> {:?}", name, case); match case { TestCase::Test(ref bin, ref val) => { - assert_eq!(&codec.decode(&codec.encode_bytes(val)?[..])?, val); - assert_eq!(&codec.decode(&bin[..])?, val); + assert_eq!(&codec.decode(&mut &codec.encode_bytes(val)?[..])?, val); + assert_eq!(&codec.decode(&mut &bin[..])?, val); assert_eq!(&codec.encode_bytes(val)?, bin); } TestCase::NondeterministicTest(ref bin, ref val) => { @@ -253,25 +257,25 @@ mod samples_tests { // written so that while strictly // "nondeterministic", the order of keys in // dictionaries follows Preserves order. - assert_eq!(&codec.decode(&codec.encode_bytes(val)?[..])?, val); - assert_eq!(&codec.decode(&bin[..])?, val); + assert_eq!(&codec.decode(&mut &codec.encode_bytes(val)?[..])?, val); + assert_eq!(&codec.decode(&mut &bin[..])?, val); assert_eq!(&codec.encode_bytes(val)?, bin); } TestCase::StreamingTest(ref bin, ref val) => { - assert_eq!(&codec.decode(&codec.encode_bytes(val)?[..])?, val); - assert_eq!(&codec.decode(&bin[..])?, val); + assert_eq!(&codec.decode(&mut &codec.encode_bytes(val)?[..])?, val); + assert_eq!(&codec.decode(&mut &bin[..])?, val); } TestCase::ParseError(_) => (), TestCase::ParseShort(_) => (), TestCase::DecodeError(ref bin) => { - match codec.decode(&bin[..]) { + match codec.decode(&mut &bin[..]) { Ok(_) => panic!("Unexpected success"), Err(codec::Error::Syntax(_)) => (), Err(e) => panic!("Unexpected error {:?}", e), } } TestCase::DecodeShort(ref bin) => { - match codec.decode(&bin[..]) { + match codec.decode(&mut &bin[..]) { Ok(_) => panic!("Unexpected success"), Err(codec::Error::Eof) => (), Err(e) => panic!("Unexpected error {:?}", e), diff --git a/implementations/rust/src/value/codec.rs b/implementations/rust/src/value/codec.rs index eb24cda..ce4df8f 100644 --- a/implementations/rust/src/value/codec.rs +++ b/implementations/rust/src/value/codec.rs @@ -21,7 +21,7 @@ impl Codec { Codec { decode_placeholders: None, encode_placeholders: None } } - pub fn decoder<'a, R: Read>(&'a self, read: R) -> Decoder<'a, R> { + pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'r, 'a, R> { Decoder::new(read, self.decode_placeholders.as_ref()) } @@ -29,7 +29,7 @@ impl Codec { Encoder::new(write, self.encode_placeholders.as_ref()) } - pub fn decode(&self, read: R) -> Result { + pub fn decode<'r, R: Read>(&self, read: &'r mut R) -> Result { self.decoder(read).next() } diff --git a/implementations/rust/src/value/decoder.rs b/implementations/rust/src/value/decoder.rs index 1ae0e89..51aed6b 100644 --- a/implementations/rust/src/value/decoder.rs +++ b/implementations/rust/src/value/decoder.rs @@ -40,16 +40,20 @@ impl Error { pub type DecodePlaceholderMap = std::collections::BTreeMap; -pub struct Decoder<'a, R: Read> { - read: R, +pub struct Decoder<'a, 'b, R: Read> { + read: &'a mut R, index: usize, buf: Box>>, - placeholders: Option<&'a DecodePlaceholderMap>, + placeholders: Option<&'b DecodePlaceholderMap>, read_annotations: bool, } -impl<'a, R: Read> Decoder<'a, R> { - pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap>) -> Self { +fn decodeint(bs: &[u8]) -> BigInt { + BigInt::from_signed_bytes_be(bs) +} + +impl<'a, 'b, R: Read> Decoder<'a, 'b, R> { + pub fn new(read: &'a mut R, placeholders: Option<&'b DecodePlaceholderMap>) -> Self { Decoder{ read, index: 0, @@ -161,13 +165,9 @@ impl<'a, R: Read> Decoder<'a, R> { } } - pub fn decodeint(bs: &[u8]) -> BigInt { - BigInt::from_signed_bytes_be(bs) - } - pub fn decodebinary(minor: AtomMinor, bs: Vec) -> Result { Ok(match minor { - AtomMinor::SignedInteger => Value::from(Self::decodeint(&bs)).wrap(), + AtomMinor::SignedInteger => Value::from(decodeint(&bs)).wrap(), AtomMinor::String => Value::from(std::str::from_utf8(&bs)?).wrap(), AtomMinor::ByteString => Value::from(bs).wrap(), AtomMinor::Symbol => Value::symbol(std::str::from_utf8(&bs)?).wrap(), diff --git a/implementations/rust/src/value/ser.rs b/implementations/rust/src/value/ser.rs index a72b39c..8781497 100644 --- a/implementations/rust/src/value/ser.rs +++ b/implementations/rust/src/value/ser.rs @@ -115,8 +115,8 @@ impl serde::Serializer for Serializer { { if name == crate::value::value::MAGIC { let v = to_value(value)?; - let buf: &[u8] = v.value().as_bytestring().ok_or(Error::InternalMagicError)?; - crate::value::Decoder::new(buf, None).next().or(Err(Error::InternalMagicError)) + let mut buf: &[u8] = v.value().as_bytestring().ok_or(Error::InternalMagicError)?; + crate::value::Decoder::new(&mut buf, None).next().or(Err(Error::InternalMagicError)) } else { // TODO: This is apparently discouraged, and we should apparently just serialize `value`? Ok(Value::simple_record(name, vec![to_value(value)?]).wrap()) diff --git a/implementations/rust/src/value/value.rs b/implementations/rust/src/value/value.rs index 8418f95..856a877 100644 --- a/implementations/rust/src/value/value.rs +++ b/implementations/rust/src/value/value.rs @@ -591,7 +591,7 @@ impl serde::Serialize for AValue { impl<'de> serde::Deserialize<'de> for Value { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; - let v = crate::value::Decoder::new(&buf[..], None).next() + let v = crate::value::Decoder::new(&mut &buf[..], None).next() .or(Err(serde::de::Error::custom("Internal error")))?; Ok(v.value().clone()) } @@ -600,7 +600,7 @@ impl<'de> serde::Deserialize<'de> for Value { impl<'de> serde::Deserialize<'de> for AValue { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; - crate::value::Decoder::new(&buf[..], None).next() + crate::value::Decoder::new(&mut &buf[..], None).next() .or(Err(serde::de::Error::custom("Internal error"))) } }