Remove the Result<T, Error> type alias.

4 files changed, 30 insertions, 30 deletions

diff --git a/src/events/binary_reader.rs b/src/events/binary_reader.rs
index e077904..553040d 100644
--- a/src/events/binary_reader.rs
+++ b/src/events/binary_reader.rs
@@ -4,7 +4,7 @@ use std::mem::size_of;
 use std::string::{FromUtf16Error, FromUtf8Error};
 
 use events::Event;
-use {u64_to_usize, Date, Error, Result};
+use {u64_to_usize, Date, Error};
 
 impl From<FromUtf8Error> for Error {
     fn from(_: FromUtf8Error) -> Error {
@@ -69,7 +69,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         byte_len <= self.max_allocation_bytes as u64
     }
 
-    fn allocate_vec<T>(&self, len: u64, size: usize) -> Result<Vec<T>> {
+    fn allocate_vec<T>(&self, len: u64, size: usize) -> Result<Vec<T>, Error> {
         if self.can_allocate(len, size) {
             Ok(Vec::with_capacity(len as usize))
         } else {
@@ -77,7 +77,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         }
     }
 
-    fn read_trailer(&mut self) -> Result<()> {
+    fn read_trailer(&mut self) -> Result<(), Error> {
         self.reader.seek(SeekFrom::Start(0))?;
         let mut magic = [0; 8];
         self.reader.read_exact(&mut magic)?;
@@ -123,7 +123,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(())
     }
 
-    fn read_ints(&mut self, len: u64, size: u8) -> Result<Vec<u64>> {
+    fn read_ints(&mut self, len: u64, size: u8) -> Result<Vec<u64>, Error> {
         let mut ints = self.allocate_vec(len, size as usize)?;
         for _ in 0..len {
             match size {
@@ -137,12 +137,12 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(ints)
     }
 
-    fn read_refs(&mut self, len: u64) -> Result<Vec<u64>> {
+    fn read_refs(&mut self, len: u64) -> Result<Vec<u64>, Error> {
         let ref_size = self.ref_size;
         self.read_ints(len, ref_size)
     }
 
-    fn read_object_len(&mut self, len: u8) -> Result<u64> {
+    fn read_object_len(&mut self, len: u8) -> Result<u64, Error> {
         if (len & 0x0f) == 0x0f {
             let len_power_of_two = self.reader.read_u8()? & 0x03;
             Ok(match len_power_of_two {
@@ -157,14 +157,14 @@ impl<R: Read + Seek> BinaryReader<R> {
         }
     }
 
-    fn read_data(&mut self, len: u64) -> Result<Vec<u8>> {
+    fn read_data(&mut self, len: u64) -> Result<Vec<u8>, Error> {
         let mut data = self.allocate_vec(len, size_of::<u8>())?;
         data.resize(len as usize, 0);
         self.reader.read_exact(&mut data)?;
         Ok(data)
     }
 
-    fn seek_to_object(&mut self, object_ref: u64) -> Result<u64> {
+    fn seek_to_object(&mut self, object_ref: u64) -> Result<u64, Error> {
         let object_ref = u64_to_usize(object_ref)?;
         let offset = *self
             .object_offsets
@@ -173,7 +173,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(self.reader.seek(SeekFrom::Start(offset))?)
     }
 
-    fn read_next(&mut self) -> Result<Option<Event>> {
+    fn read_next(&mut self) -> Result<Option<Event>, Error> {
         if self.ref_size == 0 {
             // Initialise here rather than in new
             self.read_trailer()?;
@@ -306,9 +306,9 @@ impl<R: Read + Seek> BinaryReader<R> {
 }
 
 impl<R: Read + Seek> Iterator for BinaryReader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         if self.finished {
             None
         } else {
diff --git a/src/events/mod.rs b/src/events/mod.rs
index b933ceb..cf5aa67 100644
--- a/src/events/mod.rs
+++ b/src/events/mod.rs
@@ -8,7 +8,7 @@ mod xml_writer;
 pub use self::xml_writer::XmlWriter;
 
 use std::io::{Read, Seek, SeekFrom};
-use {Date, Result};
+use {Date, Error};
 
 /// An encoding of a plist as a flat structure.
 ///
@@ -55,7 +55,7 @@ impl<R: Read + Seek> Reader<R> {
         Reader(ReaderInner::Uninitialized(Some(reader)))
     }
 
-    fn is_binary(reader: &mut R) -> Result<bool> {
+    fn is_binary(reader: &mut R) -> Result<bool, Error> {
         reader.seek(SeekFrom::Start(0))?;
         let mut magic = [0; 8];
         reader.read_exact(&mut magic)?;
@@ -66,9 +66,9 @@ impl<R: Read + Seek> Reader<R> {
 }
 
 impl<R: Read + Seek> Iterator for Reader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         let mut reader = match self.0 {
             ReaderInner::Xml(ref mut parser) => return parser.next(),
             ReaderInner::Binary(ref mut parser) => return parser.next(),
@@ -91,5 +91,5 @@ impl<R: Read + Seek> Iterator for Reader<R> {
 }
 
 pub trait Writer {
-    fn write(&mut self, event: &Event) -> Result<()>;
+    fn write(&mut self, event: &Event) -> Result<(), Error>;
 }
diff --git a/src/events/xml_reader.rs b/src/events/xml_reader.rs
index 46e0062..6bb9936 100644
--- a/src/events/xml_reader.rs
+++ b/src/events/xml_reader.rs
@@ -4,7 +4,7 @@ use std::str::FromStr;
 use xml_rs::reader::{EventReader, ParserConfig, XmlEvent};
 
 use events::Event;
-use {Date, Error, Result};
+use {Date, Error};
 
 pub struct XmlReader<R: Read> {
     xml_reader: EventReader<R>,
@@ -30,9 +30,9 @@ impl<R: Read> XmlReader<R> {
         }
     }
 
-    fn read_content<F>(&mut self, f: F) -> Result<Event>
+    fn read_content<F>(&mut self, f: F) -> Result<Event, Error>
     where
-        F: FnOnce(String) -> Result<Event>,
+        F: FnOnce(String) -> Result<Event, Error>,
     {
         match self.xml_reader.next() {
             Ok(XmlEvent::Characters(s)) => f(s),
@@ -52,7 +52,7 @@ impl<R: Read> XmlReader<R> {
         }
     }
 
-    fn read_next(&mut self) -> Option<Result<Event>> {
+    fn read_next(&mut self) -> Option<Result<Event, Error>> {
         loop {
             match self.next_event() {
                 Ok(XmlEvent::StartElement { name, .. }) => {
@@ -126,9 +126,9 @@ impl<R: Read> XmlReader<R> {
 }
 
 impl<R: Read> Iterator for XmlReader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         if self.finished {
             None
         } else {
diff --git a/src/events/xml_writer.rs b/src/events/xml_writer.rs
index f89ea81..08f399f 100644
--- a/src/events/xml_writer.rs
+++ b/src/events/xml_writer.rs
@@ -6,7 +6,7 @@ use xml_rs::namespace::Namespace;
 use xml_rs::writer::{EmitterConfig, Error as XmlWriterError, EventWriter, XmlEvent};
 
 use events::{Event, Writer};
-use {Error, Result};
+use Error;
 
 impl From<XmlWriterError> for Error {
     fn from(err: XmlWriterError) -> Error {
@@ -54,14 +54,14 @@ impl<W: Write> XmlWriter<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<(), Error> {
         self.start_element(name)?;
         self.write_value(value)?;
         self.end_element(name)?;
         Ok(())
     }
 
-    fn start_element(&mut self, name: &str) -> Result<()> {
+    fn start_element(&mut self, name: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::StartElement {
             name: Name::local(name),
             attributes: Cow::Borrowed(&[]),
@@ -70,19 +70,19 @@ impl<W: Write> XmlWriter<W> {
         Ok(())
     }
 
-    fn end_element(&mut self, name: &str) -> Result<()> {
+    fn end_element(&mut self, name: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::EndElement {
             name: Some(Name::local(name)),
         })?;
         Ok(())
     }
 
-    fn write_value(&mut self, value: &str) -> Result<()> {
+    fn write_value(&mut self, value: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::Characters(value))?;
         Ok(())
     }
 
-    fn maybe_end_plist(&mut self) -> Result<()> {
+    fn maybe_end_plist(&mut self) -> Result<(), Error> {
         // If there are no more open tags then write the </plist> element
         if self.stack.len() == 1 {
             // We didn't tell the xml_writer about the <plist> tag so we'll skip telling it
@@ -96,13 +96,13 @@ impl<W: Write> XmlWriter<W> {
         Ok(())
     }
 
-    pub fn write(&mut self, event: &Event) -> Result<()> {
+    pub fn write(&mut self, event: &Event) -> Result<(), Error> {
         <Self as Writer>::write(self, event)
     }
 }
 
 impl<W: Write> Writer for XmlWriter<W> {
-    fn write(&mut self, event: &Event) -> Result<()> {
+    fn write(&mut self, event: &Event) -> Result<(), Error> {
         match self.stack.pop() {
             Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
                 match *event {