Improve error situation

2 files changed, 41 insertions, 48 deletions

diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index 90422c2..e32dd4a 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -4,7 +4,7 @@ use std::io::Read;
 use std::str::FromStr;
 use xml_rs::reader::{EventReader as XmlEventReader, ParserConfig, XmlEvent};
 
-use super::super::{ReadError, ReadResult, PlistEvent};
+use {Error, Result, PlistEvent};
 
 pub struct EventReader<R: Read> {
     xml_reader: XmlEventReader<R>,
@@ -31,8 +31,8 @@ impl<R: Read> EventReader<R> {
         }
     }
 
-    fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent>
-        where F: FnOnce(String) -> ReadResult<PlistEvent>
+    fn read_content<F>(&mut self, f: F) -> Result<PlistEvent>
+        where F: FnOnce(String) -> Result<PlistEvent>
     {
         match self.xml_reader.next() {
             Ok(XmlEvent::Characters(s)) => f(s),
@@ -40,11 +40,11 @@ impl<R: Read> EventReader<R> {
                 self.queued_event = Some(event);
                 f("".to_owned())
             }
-            _ => Err(ReadError::InvalidData),
+            _ => Err(Error::InvalidData),
         }
     }
 
-    fn next_event(&mut self) -> Result<XmlEvent, ()> {
+    fn next_event(&mut self) -> ::std::result::Result<XmlEvent, ()> {
         if let Some(event) = self.queued_event.take() {
             Ok(event)
         } else {
@@ -52,7 +52,7 @@ impl<R: Read> EventReader<R> {
         }
     }
 
-    fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn read_next(&mut self) -> Option<Result<PlistEvent>> {
         loop {
             match self.next_event() {
                 Ok(XmlEvent::StartElement { name, .. }) => {
@@ -71,7 +71,7 @@ impl<R: Read> EventReader<R> {
                                 let s: String = s.replace(" ", "").replace("\t", "");
                                 match FromBase64::from_base64(&s[..]) {
                                     Ok(b) => Ok(PlistEvent::DataValue(b)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
@@ -85,7 +85,7 @@ impl<R: Read> EventReader<R> {
                             return Some(self.read_content(|s| {
                                 match FromStr::from_str(&s) {
                                     Ok(i) => Ok(PlistEvent::IntegerValue(i)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
@@ -93,22 +93,22 @@ impl<R: Read> EventReader<R> {
                             return Some(self.read_content(|s| {
                                 match FromStr::from_str(&s) {
                                     Ok(f) => Ok(PlistEvent::RealValue(f)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
                         "string" => {
                             return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s))))
                         }
-                        _ => return Some(Err(ReadError::InvalidData)),
+                        _ => return Some(Err(Error::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(ReadError::InvalidData)),
-                        None => return Some(Err(ReadError::InvalidData)),
+                        Some(ref _open_name) => return Some(Err(Error::InvalidData)),
+                        None => return Some(Err(Error::InvalidData)),
                     }
 
                     match &name.local_name[..] {
@@ -121,10 +121,10 @@ impl<R: Read> EventReader<R> {
                 Ok(XmlEvent::EndDocument) => {
                     match self.element_stack.is_empty() {
                         true => return None,
-                        false => return Some(Err(ReadError::UnexpectedEof)),
+                        false => return Some(Err(Error::UnexpectedEof)),
                     }
                 }
-                Err(_) => return Some(Err(ReadError::InvalidData)),
+                Err(_) => return Some(Err(Error::InvalidData)),
                 _ => (),
             }
         }
@@ -132,9 +132,9 @@ impl<R: Read> EventReader<R> {
 }
 
 impl<R: Read> Iterator for EventReader<R> {
-    type Item = ReadResult<PlistEvent>;
+    type Item = Result<PlistEvent>;
 
-    fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn next(&mut self) -> Option<Result<PlistEvent>> {
         if self.finished {
             None
         } else {
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index efca29e..633181b 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -7,7 +7,7 @@ use xml_rs::namespace::Namespace;
 use xml_rs::writer::{EventWriter as XmlEventWriter, EmitterConfig};
 use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
 
-use PlistEvent;
+use {Error, EventWriter as EventWriterTrait, PlistEvent, Result};
 
 enum Element {
     Dictionary(DictionaryState),
@@ -48,46 +48,39 @@ impl<W: Write> EventWriter<W> {
         }
     }
 
-    fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<(), ()> {
+    fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<()> {
         try!(self.start_element(name));
         try!(self.write_value(value));
         try!(self.end_element(name));
         Ok(())
     }
 
-    fn start_element(&mut self, name: &str) -> Result<(), ()> {
-        let result = self.xml_writer.write(WriteXmlEvent::StartElement {
+    fn start_element(&mut self, name: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::StartElement {
             name: Name::local(name),
             attributes: Cow::Borrowed(&[]),
             namespace: Cow::Borrowed(&self.empty_namespace),
-        });
-
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+        }));
+        Ok(())
     }
 
-    fn end_element(&mut self, name: &str) -> Result<(), ()> {
-        let result = self.xml_writer
-                         .write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) });
-
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+    fn end_element(&mut self, name: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) }));
+        Ok(())
     }
 
-    fn write_value(&mut self, value: &str) -> Result<(), ()> {
-        let result = self.xml_writer.write(WriteXmlEvent::Characters(value));
+    fn write_value(&mut self, value: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::Characters(value)));
+        Ok(())
+    }
 
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+    pub fn write(&mut self, event: &PlistEvent) -> Result<()> {
+        <Self as EventWriterTrait>::write(self, event)
     }
+}
 
-    pub fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
+impl<W: Write> EventWriterTrait for EventWriter<W> {
+    fn write(&mut self, event: &PlistEvent) -> Result<()> {
         match self.stack.pop() {
             Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
                 match *event {
@@ -96,7 +89,7 @@ impl<W: Write> EventWriter<W> {
                         self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
                     }
                     PlistEvent::EndDictionary => try!(self.end_element("dict")),
-                    _ => return Err(()), // Invalid event
+                    _ => return Err(Error::InvalidData),
                 };
                 return Ok(());
             }
@@ -118,23 +111,23 @@ impl<W: Write> EventWriter<W> {
 
                         match result {
                             Ok(()) => (),
-                            Err(_) => return Err(()),
+                            Err(_) => return Err(Error::InvalidData),
                         }
 
                         self.stack.push(Element::Root);
                         return Ok(());
                     }
-                    _ => return Err(()), // Invalid event
+                    _ => return Err(Error::InvalidData),
                 }
             }
         }
 
         Ok(match *event {
-            PlistEvent::StartPlist => return Err(()), // Invalid event
+            PlistEvent::StartPlist => return Err(Error::InvalidData),
             PlistEvent::EndPlist => {
                 try!(self.end_element("plist"));
                 if let Some(Element::Root) = self.stack.pop() {} else {
-                    return Err(()); // Invalid event
+                    return Err(Error::InvalidData);
                 }
             }
 
@@ -145,7 +138,7 @@ impl<W: Write> EventWriter<W> {
             PlistEvent::EndArray => {
                 try!(self.end_element("array"));
                 if let Some(Element::Array) = self.stack.pop() {} else {
-                    return Err(()); // Invalid event
+                    return Err(Error::InvalidData);
                 }
             }
 
@@ -153,7 +146,7 @@ impl<W: Write> EventWriter<W> {
                 try!(self.start_element("dict"));
                 self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
             }
-            PlistEvent::EndDictionary => return Err(()), // Invalid event
+            PlistEvent::EndDictionary => return Err(Error::InvalidData),
 
             PlistEvent::BooleanValue(true) => {
                 try!(self.start_element("true"));