Rename StreamingParser to EventReader and Writer to EventWriter

7 files changed, 98 insertions, 98 deletions

diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index 0ac39d4..460dbd8 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -1,3 +1,3 @@
 mod reader;
 
-pub use self::reader::StreamingParser;
\ No newline at end of file
+pub use self::reader::EventReader;
\ No newline at end of file
diff --git a/src/binary/reader.rs b/src/binary/reader.rs
index 837f216..11c20cc 100644
--- a/src/binary/reader.rs
+++ b/src/binary/reader.rs
@@ -4,20 +4,20 @@ use chrono::{TimeZone, UTC};
 use std::io::{Cursor, Read, Seek, SeekFrom};
 use std::string::FromUtf16Error;
 
-use {ParserError, ParserResult, PlistEvent};
+use {ReadError, ReadResult, PlistEvent};
 
-impl From<ByteorderError> for ParserError {
-	fn from(err: ByteorderError) -> ParserError {
+impl From<ByteorderError> for ReadError {
+	fn from(err: ByteorderError) -> ReadError {
 		match err {
-			ByteorderError::UnexpectedEOF => ParserError::UnexpectedEof,
-			ByteorderError::Io(err) => ParserError::Io(err)
+			ByteorderError::UnexpectedEOF => ReadError::UnexpectedEof,
+			ByteorderError::Io(err) => ReadError::Io(err)
 		}
 	}
 }
 
-impl From<FromUtf16Error> for ParserError {
-	fn from(_: FromUtf16Error) -> ParserError {
-		ParserError::InvalidData
+impl From<FromUtf16Error> for ReadError {
+	fn from(_: FromUtf16Error) -> ReadError {
+		ReadError::InvalidData
 	}
 }
 
@@ -34,7 +34,7 @@ enum StackType {
 
 /// https://opensource.apple.com/source/CF/CF-550/CFBinaryPList.c
 /// https://hg.python.org/cpython/file/3.4/Lib/plistlib.py
-pub struct StreamingParser<R> {
+pub struct EventReader<R> {
 	stack: Vec<StackItem>,
 	object_offsets: Vec<u64>,
 	reader: R,
@@ -42,9 +42,9 @@ pub struct StreamingParser<R> {
 	finished: bool
 }
 
-impl<R: Read+Seek> StreamingParser<R> {
-	pub fn new(reader: R) -> StreamingParser<R> {
-		StreamingParser {
+impl<R: Read+Seek> EventReader<R> {
+	pub fn new(reader: R) -> EventReader<R> {
+		EventReader {
 			stack: Vec::new(),
 			object_offsets: Vec::new(),
 			reader: reader,
@@ -53,7 +53,7 @@ impl<R: Read+Seek> StreamingParser<R> {
 		}
 	}
 
-	fn read_trailer(&mut self) -> ParserResult<()> {
+	fn read_trailer(&mut self) -> ReadResult<()> {
 		try!(self.reader.seek(SeekFrom::Start(0)));
 		let mut magic = [0; 8];
 		try!(self.reader.read(&mut magic));
@@ -81,7 +81,7 @@ impl<R: Read+Seek> StreamingParser<R> {
 		Ok(())
 	}
 
-	fn read_ints(&mut self, len: u64, size: u8) -> ParserResult<Vec<u64>> {
+	fn read_ints(&mut self, len: u64, size: u8) -> ReadResult<Vec<u64>> {
 		let mut ints = Vec::with_capacity(len as usize);
 		// TODO: Is the match hoisted out of the loop?
 		for _ in 0..len {
@@ -90,18 +90,18 @@ impl<R: Read+Seek> StreamingParser<R> {
 				2 => ints.push(try!(self.reader.read_u16::<BigEndian>()) as u64),
 				4 => ints.push(try!(self.reader.read_u32::<BigEndian>()) as u64),
 				8 => ints.push(try!(self.reader.read_u64::<BigEndian>()) as u64),
-				_ => return Err(ParserError::InvalidData)
+				_ => return Err(ReadError::InvalidData)
 			}
 		}
 		Ok(ints)
 	}
 
-	fn read_refs(&mut self, len: u64) -> ParserResult<Vec<u64>> {
+	fn read_refs(&mut self, len: u64) -> ReadResult<Vec<u64>> {
 		let ref_size = self.ref_size;
 		self.read_ints(len, ref_size)
 	}
 
-	fn read_object_len(&mut self, len: u8) -> ParserResult<u64> {
+	fn read_object_len(&mut self, len: u8) -> ReadResult<u64> {
 		if (len & 0xf) == 0xf {
 			let len_power_of_two = try!(self.reader.read_u8()) & 0x3;
 			Ok(match len_power_of_two {
@@ -109,21 +109,21 @@ impl<R: Read+Seek> StreamingParser<R> {
 				1 => try!(self.reader.read_u16::<BigEndian>()) as u64,
 				2 => try!(self.reader.read_u32::<BigEndian>()) as u64,
 				3 => try!(self.reader.read_u64::<BigEndian>()),
-				_ => return Err(ParserError::InvalidData)
+				_ => return Err(ReadError::InvalidData)
 			})
 		} else {
 			Ok(len as u64)
 		}
 	}
 
-	fn read_data(&mut self, len: u64) -> ParserResult<Vec<u8>> {
+	fn read_data(&mut self, len: u64) -> ReadResult<Vec<u8>> {
 		let mut data = vec![0; len as usize];
 		let mut total_read = 0usize;
 
 		while (total_read as u64) < len {
 			let read = try!(self.reader.read(&mut data[total_read..]));
 			if read == 0 {
-				return Err(ParserError::UnexpectedEof);
+				return Err(ReadError::UnexpectedEof);
 			}
 			total_read += read;
 		}
@@ -131,13 +131,13 @@ impl<R: Read+Seek> StreamingParser<R> {
 		Ok(data)
 	}
 
-	fn seek_to_object(&mut self, object_ref: u64) -> ParserResult<u64> {
+	fn seek_to_object(&mut self, object_ref: u64) -> ReadResult<u64> {
 		let offset = *&self.object_offsets[object_ref as usize];
 		let pos = try!(self.reader.seek(SeekFrom::Start(offset)));
 		Ok(pos)
 	}
 
-	fn read_next(&mut self) -> ParserResult<Option<PlistEvent>> {
+	fn read_next(&mut self) -> ReadResult<Option<PlistEvent>> {
 		if self.ref_size == 0 {
 			// Initialise here rather than in new
 			try!(self.read_trailer());
@@ -170,19 +170,19 @@ impl<R: Read+Seek> StreamingParser<R> {
 		let size = token & 0x0f;
 
 		let result = match (ty, size) {
-			(0x0, 0x00) => return Err(ParserError::UnsupportedType), // null
+			(0x0, 0x00) => return Err(ReadError::UnsupportedType), // null
 			(0x0, 0x08) => Some(PlistEvent::BooleanValue(false)),
 			(0x0, 0x09) => Some(PlistEvent::BooleanValue(true)),
-			(0x0, 0x0f) => return Err(ParserError::UnsupportedType), // fill
+			(0x0, 0x0f) => return Err(ReadError::UnsupportedType), // fill
 			(0x1, 0) => Some(PlistEvent::IntegerValue(try!(self.reader.read_u8()) as i64)),
 			(0x1, 1) => Some(PlistEvent::IntegerValue(try!(self.reader.read_u16::<BigEndian>()) as i64)),
 			(0x1, 2) => Some(PlistEvent::IntegerValue(try!(self.reader.read_u32::<BigEndian>()) as i64)),
 			(0x1, 3) => Some(PlistEvent::IntegerValue(try!(self.reader.read_i64::<BigEndian>()))),
-			(0x1, 4) => return Err(ParserError::UnsupportedType), // 128 bit int
-			(0x1, _) => return Err(ParserError::UnsupportedType), // variable length int
+			(0x1, 4) => return Err(ReadError::UnsupportedType), // 128 bit int
+			(0x1, _) => return Err(ReadError::UnsupportedType), // variable length int
 			(0x2, 2) => Some(PlistEvent::RealValue(try!(self.reader.read_f32::<BigEndian>()) as f64)),
 			(0x2, 3) => Some(PlistEvent::RealValue(try!(self.reader.read_f64::<BigEndian>()))),
-			(0x2, _) => return Err(ParserError::UnsupportedType), // odd length float
+			(0x2, _) => return Err(ReadError::UnsupportedType), // odd length float
 			(0x3, 3) => { // Date
 				// Seconds since 1/1/2001 00:00:00
 				let timestamp = try!(self.reader.read_f64::<BigEndian>());
@@ -253,17 +253,17 @@ impl<R: Read+Seek> StreamingParser<R> {
 
 				Some(PlistEvent::StartDictionary(Some(len as u64)))
 			},
-			(_, _) => return Err(ParserError::InvalidData)
+			(_, _) => return Err(ReadError::InvalidData)
 		};
 
 		Ok(result)
 	}
 }
 
-impl<R: Read+Seek> Iterator for StreamingParser<R> {
-	type Item = ParserResult<PlistEvent>;
+impl<R: Read+Seek> Iterator for EventReader<R> {
+	type Item = ReadResult<PlistEvent>;
 
-	fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
+	fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
 		if self.finished {
 			None
 		} else {
@@ -296,7 +296,7 @@ mod tests {
 		use PlistEvent::*;
 
 		let reader = File::open(&Path::new("./tests/data/binary.plist")).unwrap();
-		let streaming_parser = StreamingParser::new(reader);
+		let streaming_parser = EventReader::new(reader);
 		let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
 
 		let comparison = &[
diff --git a/src/builder.rs b/src/builder.rs
index fc33e1e..0b17f97 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 use std::io::{Read, Seek};
 
-use {ParserError, ParserResult, Plist, PlistEvent, StreamingParser};
+use {ReadError, ReadResult, Plist, PlistEvent, EventReader};
 
 pub type BuilderResult<T> = Result<T, BuilderError>;
 
@@ -9,12 +9,12 @@ pub type BuilderResult<T> = Result<T, BuilderError>;
 pub enum BuilderError {
 	InvalidEvent,
 	UnsupportedDictionaryKey,
-	ParserError(ParserError)
+	ReadError(ReadError)
 }
 
-impl From<ParserError> for BuilderError {
-	fn from(err: ParserError) -> BuilderError {
-		BuilderError::ParserError(err)
+impl From<ReadError> for BuilderError {
+	fn from(err: ReadError) -> BuilderError {
+		BuilderError::ReadError(err)
 	}
 }
 
@@ -23,13 +23,13 @@ pub struct Builder<T> {
 	token: Option<PlistEvent>,
 }
 
-impl<R: Read+Seek> Builder<StreamingParser<R>> {
-	pub fn new(reader: R) -> Builder<StreamingParser<R>> {
-		Builder::from_event_stream(StreamingParser::new(reader))
+impl<R: Read+Seek> Builder<EventReader<R>> {
+	pub fn new(reader: R) -> Builder<EventReader<R>> {
+		Builder::from_event_stream(EventReader::new(reader))
 	}
 }
 
-impl<T:Iterator<Item=ParserResult<PlistEvent>>> Builder<T> {
+impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
 	pub fn from_event_stream(stream: T) -> Builder<T> {
 		Builder {
 			stream: stream,
@@ -57,7 +57,7 @@ impl<T:Iterator<Item=ParserResult<PlistEvent>>> Builder<T> {
 	fn bump(&mut self) -> BuilderResult<()> {
 		self.token = match self.stream.next() {
 			Some(Ok(token)) => Some(token),
-			Some(Err(err)) => return Err(BuilderError::ParserError(err)),
+			Some(Err(err)) => return Err(BuilderError::ReadError(err)),
 			None => None,
 		};
 		Ok(())
diff --git a/src/lib.rs b/src/lib.rs
index ca9fdab..a5fa501 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -96,38 +96,38 @@ pub enum PlistEvent {
 	StringValue(String),
 }
 
-pub type ParserResult<T> = Result<T, ParserError>;
+pub type ReadResult<T> = Result<T, ReadError>;
 
 #[derive(Debug)]
-pub enum ParserError {
+pub enum ReadError {
 	InvalidData,
 	UnexpectedEof,
 	UnsupportedType,
 	Io(IoError)
 }
 
-impl From<IoError> for ParserError {
-	fn from(io_error: IoError) -> ParserError {
-		ParserError::Io(io_error)
+impl From<IoError> for ReadError {
+	fn from(io_error: IoError) -> ReadError {
+		ReadError::Io(io_error)
 	}
 }
 
-impl From<ChronoParseError> for ParserError {
-	fn from(_: ChronoParseError) -> ParserError {
-		ParserError::InvalidData
+impl From<ChronoParseError> for ReadError {
+	fn from(_: ChronoParseError) -> ReadError {
+		ReadError::InvalidData
 	}
 }
 
-pub enum StreamingParser<R: Read+Seek> {
-	Xml(xml::StreamingParser<R>),
-	Binary(binary::StreamingParser<R>)
+pub enum EventReader<R: Read+Seek> {
+	Xml(xml::EventReader<R>),
+	Binary(binary::EventReader<R>)
 }
 
-impl<R: Read+Seek> StreamingParser<R> {
-	pub fn new(mut reader: R) -> StreamingParser<R> {
-		match StreamingParser::is_binary(&mut reader) {
-			Ok(true) => StreamingParser::Binary(binary::StreamingParser::new(reader)),
-			Ok(false) | Err(_) => StreamingParser::Xml(xml::StreamingParser::new(reader))
+impl<R: Read+Seek> EventReader<R> {
+	pub fn new(mut reader: R) -> EventReader<R> {
+		match EventReader::is_binary(&mut reader) {
+			Ok(true) => EventReader::Binary(binary::EventReader::new(reader)),
+			Ok(false) | Err(_) => EventReader::Xml(xml::EventReader::new(reader))
 		}
 	}
 
@@ -145,13 +145,13 @@ impl<R: Read+Seek> StreamingParser<R> {
 	}
 }
 
-impl<R: Read+Seek> Iterator for StreamingParser<R> {
-	type Item = ParserResult<PlistEvent>;
+impl<R: Read+Seek> Iterator for EventReader<R> {
+	type Item = ReadResult<PlistEvent>;
 
-	fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
+	fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
 		match *self {
-			StreamingParser::Xml(ref mut parser) => parser.next(),
-			StreamingParser::Binary(ref mut parser) => parser.next()
+			EventReader::Xml(ref mut parser) => parser.next(),
+			EventReader::Binary(ref mut parser) => parser.next()
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/xml/mod.rs b/src/xml/mod.rs
index 71c098e..b82450a 100644
--- a/src/xml/mod.rs
+++ b/src/xml/mod.rs
@@ -1,5 +1,5 @@
 mod reader;
 mod writer;
 
-pub use self::reader::StreamingParser;
-pub use self::writer::Writer;
\ No newline at end of file
+pub use self::reader::EventReader;
+pub use self::writer::EventWriter;
\ No newline at end of file
diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index abf671d..b8def8f 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -2,19 +2,19 @@ use chrono::{DateTime, UTC};
 use rustc_serialize::base64::FromBase64;
 use std::io::Read;
 use std::str::FromStr;
-use xml_rs::reader::{EventReader, ParserConfig, XmlEvent};
+use xml_rs::reader::{EventReader as XmlEventReader, ParserConfig, XmlEvent};
 
-use super::super::{ParserError, ParserResult, PlistEvent};
+use super::super::{ReadError, ReadResult, PlistEvent};
 
-pub struct StreamingParser<R: Read> {
-	xml_reader: EventReader<R>,
+pub struct EventReader<R: Read> {
+	xml_reader: XmlEventReader<R>,
 	queued_event: Option<XmlEvent>,
 	element_stack: Vec<String>,
 	finished: bool
 }
 
-impl<R: Read> StreamingParser<R> {
-	pub fn new(reader: R) -> StreamingParser<R> {
+impl<R: Read> EventReader<R> {
+	pub fn new(reader: R) -> EventReader<R> {
 		let config = ParserConfig {
 			trim_whitespace: false,
 			whitespace_to_characters: true,
@@ -23,22 +23,22 @@ impl<R: Read> StreamingParser<R> {
 			coalesce_characters: true,
 		};
 
-		StreamingParser {
-			xml_reader: EventReader::new_with_config(reader, config),
+		EventReader {
+			xml_reader: XmlEventReader::new_with_config(reader, config),
 			queued_event: None,
 			element_stack: Vec::new(),
 			finished: false
 		}
 	}
 
-	fn read_content<F>(&mut self, f: F) -> ParserResult<PlistEvent> where F:FnOnce(String) -> ParserResult<PlistEvent> {
+	fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent> where F:FnOnce(String) -> ReadResult<PlistEvent> {
 		match self.xml_reader.next() {
 			Ok(XmlEvent::Characters(s)) => f(s),
 			Ok(event @ XmlEvent::EndElement{..}) => {
 				self.queued_event = Some(event);
 				f("".to_owned())
 			},
-			_ => Err(ParserError::InvalidData)
+			_ => Err(ReadError::InvalidData)
 		}
 	}
 
@@ -50,7 +50,7 @@ impl<R: Read> StreamingParser<R> {
 		}
 	}
 
-	fn read_next(&mut self) -> Option<ParserResult<PlistEvent>> {
+	fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
 		loop {
 			match self.next_event() {
 				Ok(XmlEvent::StartElement { name, .. }) => {
@@ -68,7 +68,7 @@ impl<R: Read> StreamingParser<R> {
 							let s: String = s.replace(" ", "").replace("\t", "");
 							match FromBase64::from_base64(&s[..]) {
 								Ok(b) => Ok(PlistEvent::DataValue(b)),
-								Err(_) => Err(ParserError::InvalidData)
+								Err(_) => Err(ReadError::InvalidData)
 							}
 						})),
 						"date" => return Some(self.read_content(|s| {
@@ -78,25 +78,25 @@ impl<R: Read> StreamingParser<R> {
 						"integer" => return Some(self.read_content(|s| {
 							match FromStr::from_str(&s)	{
 								Ok(i) => Ok(PlistEvent::IntegerValue(i)),
-								Err(_) => Err(ParserError::InvalidData)
+								Err(_) => Err(ReadError::InvalidData)
 							}
 						})),
 						"real" => return Some(self.read_content(|s| {
 							match FromStr::from_str(&s)	{
 								Ok(f) => Ok(PlistEvent::RealValue(f)),
-								Err(_) => Err(ParserError::InvalidData)
+								Err(_) => Err(ReadError::InvalidData)
 							}
 						})),
 						"string" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
-						_ => return Some(Err(ParserError::InvalidData))
+						_ => return Some(Err(ReadError::InvalidData))
 					}
 				},
 				Ok(XmlEvent::EndElement { name, .. }) => {
 					// Check the corrent element is being closed
 					match self.element_stack.pop() {
 						Some(ref open_name) if &name.local_name == open_name => (),
-						Some(ref _open_name) => return Some(Err(ParserError::InvalidData)),
-						None => return Some(Err(ParserError::InvalidData))
+						Some(ref _open_name) => return Some(Err(ReadError::InvalidData)),
+						None => return Some(Err(ReadError::InvalidData))
 					}
 
 					match &name.local_name[..] {
@@ -109,20 +109,20 @@ impl<R: Read> StreamingParser<R> {
 				Ok(XmlEvent::EndDocument) => {
 					match self.element_stack.is_empty() {
 						true => return None,
-						false => return Some(Err(ParserError::UnexpectedEof))
+						false => return Some(Err(ReadError::UnexpectedEof))
 					}
 				},
-				Err(_) => return Some(Err(ParserError::InvalidData)),
+				Err(_) => return Some(Err(ReadError::InvalidData)),
 				_ => ()
 			}
 		}
 	}
 }
 
-impl<R: Read> Iterator for StreamingParser<R> {
-	type Item = ParserResult<PlistEvent>;
+impl<R: Read> Iterator for EventReader<R> {
+	type Item = ReadResult<PlistEvent>;
 
-	fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
+	fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
 		if self.finished {
 			None
 		} else {
@@ -155,7 +155,7 @@ mod tests {
 		use PlistEvent::*;
 
 		let reader = File::open(&Path::new("./tests/data/xml.plist")).unwrap();
-		let streaming_parser = StreamingParser::new(reader);
+		let streaming_parser = EventReader::new(reader);
 		let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
 
 		let comparison = &[
@@ -188,7 +188,7 @@ mod tests {
 	#[test]
 	fn bad_data() {
 		let reader = File::open(&Path::new("./tests/data/xml_error.plist")).unwrap();
-		let streaming_parser = StreamingParser::new(reader);
+		let streaming_parser = EventReader::new(reader);
 		let events: Vec<_> = streaming_parser.collect();
 
 		assert!(events.last().unwrap().is_err());
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index bd73b1e..ec2d9db 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -4,7 +4,7 @@ use std::io::Write;
 use xml_rs::attribute::Attribute;
 use xml_rs::name::Name;
 use xml_rs::namespace::Namespace;
-use xml_rs::writer::{EventWriter, EmitterConfig};
+use xml_rs::writer::{EventWriter as XmlEventWriter, EmitterConfig};
 use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
 
 use {PlistEvent};
@@ -20,15 +20,15 @@ enum DictionaryState {
 	ExpectValue
 }
 
-pub struct Writer<W: Write> {
-	xml_writer: EventWriter<W>,
+pub struct EventWriter<W: Write> {
+	xml_writer: XmlEventWriter<W>,
 	stack: Vec<Element>,
 	// Not very nice
 	empty_namespace: Namespace
 }
 
-impl<W: Write> Writer<W> {
-	pub fn new(writer: W) -> Writer<W> {
+impl<W: Write> EventWriter<W> {
+	pub fn new(writer: W) -> EventWriter<W> {
 		let config = EmitterConfig {
 			line_separator: "\n".into(),
 			indent_string: "    ".into(),
@@ -41,8 +41,8 @@ impl<W: Write> Writer<W> {
 			autopad_comments: true
 		};
 
-		Writer {
-			xml_writer: EventWriter::new_with_config(writer, config),
+		EventWriter {
+			xml_writer: XmlEventWriter::new_with_config(writer, config),
 			stack: Vec::new(),
 			empty_namespace: Namespace::empty()
 		}
@@ -211,7 +211,7 @@ mod tests {
 		let mut cursor = Cursor::new(Vec::new());
 
 		{
-			let mut plist_w = Writer::new(&mut cursor);
+			let mut plist_w = EventWriter::new(&mut cursor);
 
 			for item in plist {
 				plist_w.write(item).unwrap();