aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/binary.rs11
-rw-r--r--src/lib.rs49
-rw-r--r--src/xml.rs56
3 files changed, 55 insertions, 61 deletions
diff --git a/src/binary.rs b/src/binary.rs
index c189c1a..0f1b707 100644
--- a/src/binary.rs
+++ b/src/binary.rs
@@ -225,12 +225,13 @@ impl<R: Read+Seek> StreamingParser<R> {
}
impl<R: Read+Seek> Iterator for StreamingParser<R> {
- type Item = PlistEvent;
+ type Item = ParserResult<PlistEvent>;
- fn next(&mut self) -> Option<PlistEvent> {
+ fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
match self.read_next() {
- Ok(result) => result,
- Err(err) => Some(PlistEvent::Error(err))
+ Ok(Some(result)) => Some(Ok(result)),
+ Err(err) => Some(Err(err)),
+ Ok(None) => None
}
}
}
@@ -249,7 +250,7 @@ mod tests {
let reader = File::open(&Path::new("./tests/data/binary.plist")).unwrap();
let streaming_parser = StreamingParser::new(reader);
- let events: Vec<PlistEvent> = streaming_parser.collect();
+ let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
let comparison = &[
StartPlist,
diff --git a/src/lib.rs b/src/lib.rs
index 8de9efa..7a00ca0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -41,11 +41,9 @@ pub enum PlistEvent {
IntegerValue(i64),
RealValue(f64),
StringValue(String),
-
- Error(ParserError)
}
-type ParserResult<T> = Result<T, ParserError>;
+pub type ParserResult<T> = Result<T, ParserError>;
#[derive(Debug)]
pub enum ParserError {
@@ -55,13 +53,6 @@ pub enum ParserError {
Io(IoError)
}
-// No two errors are the same - this is a bit annoying though
-impl PartialEq for ParserError {
- fn eq(&self, other: &ParserError) -> bool {
- false
- }
-}
-
impl From<IoError> for ParserError {
fn from(io_error: IoError) -> ParserError {
ParserError::Io(io_error)
@@ -110,9 +101,9 @@ impl<R: Read+Seek> StreamingParser<R> {
}
impl<R: Read+Seek> Iterator for StreamingParser<R> {
- type Item = PlistEvent;
+ type Item = ParserResult<PlistEvent>;
- fn next(&mut self) -> Option<PlistEvent> {
+ fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
match *self {
StreamingParser::Xml(ref mut parser) => parser.next(),
StreamingParser::Binary(ref mut parser) => parser.next()
@@ -122,7 +113,7 @@ impl<R: Read+Seek> Iterator for StreamingParser<R> {
pub type BuilderResult<T> = Result<T, BuilderError>;
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
pub enum BuilderError {
InvalidEvent,
UnsupportedDictionaryKey,
@@ -146,7 +137,7 @@ impl<R: Read + Seek> Builder<StreamingParser<R>> {
}
}
-impl<T:Iterator<Item=PlistEvent>> Builder<T> {
+impl<T:Iterator<Item=ParserResult<PlistEvent>>> Builder<T> {
pub fn from_event_stream(stream: T) -> Builder<T> {
Builder {
stream: stream,
@@ -155,24 +146,29 @@ impl<T:Iterator<Item=PlistEvent>> Builder<T> {
}
pub fn build(mut self) -> BuilderResult<Plist> {
- self.bump();
+ try!(self.bump());
if let Some(PlistEvent::StartPlist) = self.token {
- self.bump();
+ try!(self.bump());
}
let plist = try!(self.build_value());
- self.bump();
+ try!(self.bump());
match self.token {
None => (),
- Some(PlistEvent::EndPlist) => self.bump(),
+ Some(PlistEvent::EndPlist) => try!(self.bump()),
// The stream should have finished
_ => return Err(BuilderError::InvalidEvent)
};
Ok(plist)
}
- fn bump(&mut self) {
- self.token = self.stream.next();
+ fn bump(&mut self) -> BuilderResult<()> {
+ self.token = match self.stream.next() {
+ Some(Ok(token)) => Some(token),
+ Some(Err(err)) => return Err(BuilderError::ParserError(err)),
+ None => None,
+ };
+ Ok(())
}
fn build_value(&mut self) -> BuilderResult<Plist> {
@@ -192,7 +188,7 @@ impl<T:Iterator<Item=PlistEvent>> Builder<T> {
Some(PlistEvent::EndArray) => Err(BuilderError::InvalidEvent),
Some(PlistEvent::EndDictionary) => Err(BuilderError::InvalidEvent),
- Some(PlistEvent::Error(_)) => Err(BuilderError::InvalidEvent),
+
// The stream should not have ended here
None => Err(BuilderError::InvalidEvent)
}
@@ -205,7 +201,7 @@ impl<T:Iterator<Item=PlistEvent>> Builder<T> {
};
loop {
- self.bump();
+ try!(self.bump());
if let Some(PlistEvent::EndArray) = self.token {
self.token.take();
return Ok(values);
@@ -221,12 +217,11 @@ impl<T:Iterator<Item=PlistEvent>> Builder<T> {
};
loop {
-
- self.bump();
+ try!(self.bump());
match self.token.take() {
Some(PlistEvent::EndDictionary) => return Ok(values),
Some(PlistEvent::StringValue(s)) => {
- self.bump();
+ try!(self.bump());
values.insert(s, try!(self.build_value()));
},
_ => {
@@ -268,7 +263,7 @@ mod tests {
EndPlist,
];
- let builder = Builder::from_event_stream(events.into_iter());
+ let builder = Builder::from_event_stream(events.into_iter().map(|e| Ok(e)));
let plist = builder.build();
// Expected output
@@ -283,6 +278,6 @@ mod tests {
dict.insert("Birthdate".to_owned(), Plist::Integer(1564));
dict.insert("Height".to_owned(), Plist::Real(1.60));
- assert_eq!(plist, Ok(Plist::Dictionary(dict)));
+ assert_eq!(plist.unwrap(), Plist::Dictionary(dict));
}
} \ No newline at end of file
diff --git a/src/xml.rs b/src/xml.rs
index 4e02f54..a85d321 100644
--- a/src/xml.rs
+++ b/src/xml.rs
@@ -7,7 +7,7 @@ use xml_rs::reader::events::XmlEvent;
use xml_rs::writer::{EventWriter, EmitterConfig};
use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
-use super::{ParserError, PlistEvent};
+use super::{ParserError, ParserResult, PlistEvent};
pub struct Writer<W: Write> {
xml_writer: EventWriter<W>,
@@ -98,8 +98,6 @@ impl<W: Write> Writer<W> {
PlistEvent::IntegerValue(value) => try!(self.write_element_and_value("integer", &value.to_string())),
PlistEvent::RealValue(value) => try!(self.write_element_and_value("real", &value.to_string())),
PlistEvent::StringValue(value) => try!(self.write_element_and_value("string", &value)),
-
- PlistEvent::Error(_) => return Err(())
})
}
}
@@ -126,18 +124,18 @@ impl<R: Read> StreamingParser<R> {
}
}
- fn read_content<F>(&mut self, f: F) -> PlistEvent where F:FnOnce(String) -> PlistEvent {
+ fn read_content<F>(&mut self, f: F) -> ParserResult<PlistEvent> where F:FnOnce(String) -> ParserResult<PlistEvent> {
match self.xml_reader.next() {
XmlEvent::Characters(s) => f(s),
- _ => PlistEvent::Error(ParserError::InvalidData)
+ _ => Err(ParserError::InvalidData)
}
}
}
impl<R: Read> Iterator for StreamingParser<R> {
- type Item = PlistEvent;
+ type Item = ParserResult<PlistEvent>;
- fn next(&mut self) -> Option<PlistEvent> {
+ fn next(&mut self) -> Option<ParserResult<PlistEvent>> {
loop {
match self.xml_reader.next() {
XmlEvent::StartElement { name, .. } => {
@@ -145,54 +143,54 @@ impl<R: Read> Iterator for StreamingParser<R> {
self.element_stack.push(name.local_name.clone());
match &name.local_name[..] {
- "plist" => return Some(PlistEvent::StartPlist),
- "array" => return Some(PlistEvent::StartArray(None)),
- "dict" => return Some(PlistEvent::StartDictionary(None)),
- "key" => return Some(self.read_content(|s| PlistEvent::StringValue(s))),
- "true" => return Some(PlistEvent::BooleanValue(true)),
- "false" => return Some(PlistEvent::BooleanValue(false)),
+ "plist" => return Some(Ok(PlistEvent::StartPlist)),
+ "array" => return Some(Ok(PlistEvent::StartArray(None))),
+ "dict" => return Some(Ok(PlistEvent::StartDictionary(None))),
+ "key" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
+ "true" => return Some(Ok(PlistEvent::BooleanValue(true))),
+ "false" => return Some(Ok(PlistEvent::BooleanValue(false))),
"data" => return Some(self.read_content(|s| {
match FromBase64::from_base64(&s[..]) {
- Ok(b) => PlistEvent::DataValue(b),
- Err(_) => PlistEvent::Error(ParserError::InvalidData)
+ Ok(b) => Ok(PlistEvent::DataValue(b)),
+ Err(_) => Err(ParserError::InvalidData)
}
})),
- "date" => return Some(self.read_content(|s| PlistEvent::DateValue(s))),
+ "date" => return Some(self.read_content(|s| Ok(PlistEvent::DateValue(s)))),
"integer" => return Some(self.read_content(|s| {
match FromStr::from_str(&s) {
- Ok(i) => PlistEvent::IntegerValue(i),
- Err(_) => PlistEvent::Error(ParserError::InvalidData)
+ Ok(i) => Ok(PlistEvent::IntegerValue(i)),
+ Err(_) => Err(ParserError::InvalidData)
}
})),
"real" => return Some(self.read_content(|s| {
match FromStr::from_str(&s) {
- Ok(f) => PlistEvent::RealValue(f),
- Err(_) => PlistEvent::Error(ParserError::InvalidData)
+ Ok(f) => Ok(PlistEvent::RealValue(f)),
+ Err(_) => Err(ParserError::InvalidData)
}
})),
- "string" => return Some(self.read_content(|s| PlistEvent::StringValue(s))),
- _ => return Some(PlistEvent::Error(ParserError::InvalidData))
+ "string" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
+ _ => return Some(Err(ParserError::InvalidData))
}
},
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(PlistEvent::Error(ParserError::InvalidData)),
- None => return Some(PlistEvent::Error(ParserError::InvalidData))
+ Some(ref open_name) => return Some(Err(ParserError::InvalidData)),
+ None => return Some(Err(ParserError::InvalidData))
}
match &name.local_name[..] {
- "array" => return Some(PlistEvent::EndArray),
- "dict" => return Some(PlistEvent::EndDictionary),
- "plist" => return Some(PlistEvent::EndPlist),
+ "array" => return Some(Ok(PlistEvent::EndArray)),
+ "dict" => return Some(Ok(PlistEvent::EndDictionary)),
+ "plist" => return Some(Ok(PlistEvent::EndPlist)),
_ => ()
}
},
XmlEvent::EndDocument => {
match self.element_stack.is_empty() {
true => return None,
- false => return Some(PlistEvent::Error(ParserError::UnexpectedEof))
+ false => return Some(Err(ParserError::UnexpectedEof))
}
}
_ => ()
@@ -215,7 +213,7 @@ mod tests {
let reader = File::open(&Path::new("./tests/data/xml.plist")).unwrap();
let streaming_parser = StreamingParser::new(reader);
- let events: Vec<PlistEvent> = streaming_parser.collect();
+ let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
let comparison = &[
StartPlist,
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 19:38:06 +0000