From a3eca5e4e17edeffb0e7805cb349fa5fbc3a66fe Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 23 Feb 2016 07:48:15 -0800 Subject: [PATCH] refactor(stream): Rename JSONStream to StreamDeserializer This is a tad more consistent with the rest of the library. --- json/src/de.rs | 97 +++++++++++++++++++---------------- json/src/lib.rs | 2 +- json_tests/tests/test_json.rs | 26 ++++++---- 3 files changed, 70 insertions(+), 55 deletions(-) diff --git a/json/src/de.rs b/json/src/de.rs index 35cba2b..4a46c31 100644 --- a/json/src/de.rs +++ b/json/src/de.rs @@ -813,6 +813,58 @@ impl de::VariantVisitor for Deserializer } } +////////////////////////////////////////////////////////////////////////////// + +/// Iterator that deserializes a stream into multiple JSON values. +pub struct StreamDeserializer + where Iter: Iterator>, + T: de::Deserialize +{ + deser: Deserializer, + _marker: PhantomData, +} + +impl StreamDeserializer + where Iter:Iterator>, + T: de::Deserialize +{ + /// Returns an `Iterator` of decoded JSON values from an iterator over + /// `Iterator>`. + pub fn new(iter: Iter) -> StreamDeserializer { + StreamDeserializer { + deser: Deserializer::new(iter), + _marker: PhantomData + } + } +} + +impl Iterator for StreamDeserializer + where Iter: Iterator>, + T: de::Deserialize +{ + type Item = Result; + + fn next(&mut self) -> Option> { + // skip whitespaces, if any + // this helps with trailing whitespaces, since whitespaces between + // values are handled for us. + if let Err(e) = self.deser.parse_whitespace() { + return Some(Err(e)) + }; + + match self.deser.eof() { + Ok(true) => None, + Ok(false) => match de::Deserialize::deserialize(&mut self.deser) { + Ok(v) => Some(Ok(v)), + Err(e) => Some(Err(e)) + }, + Err(e) => Some(Err(e)) + } + } +} + +////////////////////////////////////////////////////////////////////////////// + /// Decodes a json value from an iterator over an iterator /// `Iterator>`. pub fn from_iter(iter: I) -> Result @@ -848,48 +900,3 @@ pub fn from_str(s: &str) -> Result { from_slice(s.as_bytes()) } - -/// Iterator over parsed JSON values -pub struct JSONStream - where Iter: Iterator>, - T: de::Deserialize -{ - deser: Deserializer, - _marker: PhantomData, -} - -/// Iterator over parsed JSON values -impl JSONStream - where Iter:Iterator>, - T: de::Deserialize { - /// Returns Iterator of decoded JSON value from an iterator over - /// `Iterator>`. - pub fn new(i: Iter) -> JSONStream { - JSONStream { - deser: Deserializer::new(i), - _marker: PhantomData - } - } -} - -impl Iterator for JSONStream - where Iter:Iterator>, - T: de::Deserialize { - type Item = Result; - fn next(&mut self) -> Option> { - // skip whitespaces, if any - // this helps with trailing whitespaces, since whitespaces between - // values are handled for us. - if let Err(e) = self.deser.parse_whitespace() { - return Some(Err(e)) - }; - match self.deser.eof() { - Ok(true) => None, - Ok(false) => match de::Deserialize::deserialize(&mut self.deser) { - Ok(v) => Some(Ok(v)), - Err(e) => Some(Err(e)) - }, - Err(e) => Some(Err(e)) - } - } -} diff --git a/json/src/lib.rs b/json/src/lib.rs index b29aeb8..736697c 100644 --- a/json/src/lib.rs +++ b/json/src/lib.rs @@ -122,7 +122,7 @@ extern crate serde; pub use self::de::{ Deserializer, - JSONStream, + StreamDeserializer, from_iter, from_reader, from_slice, diff --git a/json_tests/tests/test_json.rs b/json_tests/tests/test_json.rs index 7e6563f..a6bbb91 100644 --- a/json_tests/tests/test_json.rs +++ b/json_tests/tests/test_json.rs @@ -11,8 +11,8 @@ use serde::bytes::{ByteBuf, Bytes}; use serde_json::{ self, + StreamDeserializer, Value, - JSONStream, from_str, from_value, to_value, @@ -1416,8 +1416,10 @@ fn test_byte_buf_de() { #[test] fn test_json_stream_newlines() { let stream = "{\"x\":39} {\"x\":40}{\"x\":41}\n{\"x\":42}".to_string(); - let mut parsed:JSONStream = JSONStream::new( - stream.as_bytes().iter().map(|byte| Ok(*byte))); + let mut parsed: StreamDeserializer = StreamDeserializer::new( + stream.as_bytes().iter().map(|byte| Ok(*byte)) + ); + assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(), &Value::U64(39)); assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(), @@ -1432,8 +1434,10 @@ fn test_json_stream_newlines() { #[test] fn test_json_stream_trailing_whitespaces() { let stream = "{\"x\":42} \t\n".to_string(); - let mut parsed:JSONStream = JSONStream::new( - stream.as_bytes().iter().map(|byte| Ok(*byte))); + let mut parsed: StreamDeserializer = StreamDeserializer::new( + stream.as_bytes().iter().map(|byte| Ok(*byte)) + ); + assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(), &Value::U64(42)); assert!(parsed.next().is_none()); @@ -1442,8 +1446,10 @@ fn test_json_stream_trailing_whitespaces() { #[test] fn test_json_stream_truncated() { let stream = "{\"x\":40}\n{\"x\":".to_string(); - let mut parsed:JSONStream = JSONStream::new( - stream.as_bytes().iter().map(|byte| Ok(*byte))); + let mut parsed: StreamDeserializer = StreamDeserializer::new( + stream.as_bytes().iter().map(|byte| Ok(*byte)) + ); + assert_eq!(parsed.next().unwrap().ok().unwrap().lookup("x").unwrap(), &Value::U64(40)); assert!(parsed.next().unwrap().is_err()); @@ -1453,7 +1459,9 @@ fn test_json_stream_truncated() { #[test] fn test_json_stream_empty() { let stream = "".to_string(); - let mut parsed:JSONStream = JSONStream::new( - stream.as_bytes().iter().map(|byte| Ok(*byte))); + let mut parsed: StreamDeserializer = StreamDeserializer::new( + stream.as_bytes().iter().map(|byte| Ok(*byte)) + ); + assert!(parsed.next().is_none()); }