Use Error in fewer places.

7 files changed, 23 insertions, 33 deletions

diff --git a/src/date.rs b/src/date.rs
index ba7978f..5394ada 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -3,8 +3,6 @@ use std::fmt;
 use std::result::Result as StdResult;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use Error;
-
 /// A UTC timestamp. Used for serialization to and from the plist date type.
 #[derive(Clone, Copy, Hash, PartialEq)]
 pub struct Date {
@@ -12,9 +10,9 @@ pub struct Date {
 }
 
 impl Date {
-    pub(crate) fn from_rfc3339(date: &str) -> Result<Self, Error> {
+    pub(crate) fn from_rfc3339(date: &str) -> Result<Self, ()> {
         Ok(Date {
-            inner: humantime::parse_rfc3339(date).map_err(|_| Error::InvalidData)?,
+            inner: humantime::parse_rfc3339(date).map_err(|_| ())?,
         })
     }
 
@@ -22,14 +20,14 @@ impl Date {
         format!("{}", humantime::format_rfc3339(self.inner))
     }
 
-    pub(crate) fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date, Error> {
+    pub(crate) fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date, ()> {
         // `timestamp` is the number of seconds since the plist epoch of 1/1/2001 00:00:00.
         // `PLIST_EPOCH_UNIX_TIMESTAMP` is the unix timestamp of the plist epoch.
         const PLIST_EPOCH_UNIX_TIMESTAMP: u64 = 978_307_200;
         let plist_epoch = UNIX_EPOCH + Duration::from_secs(PLIST_EPOCH_UNIX_TIMESTAMP);
 
         if !timestamp.is_finite() {
-            return Err(Error::InvalidData);
+            return Err(());
         }
 
         let is_negative = timestamp < 0.0;
@@ -118,7 +116,7 @@ pub mod serde_impls {
         where
             E: Error,
         {
-            Date::from_rfc3339(v).map_err(|_| E::invalid_value(Unexpected::Str(v), &self))
+            Date::from_rfc3339(v).map_err(|()| E::invalid_value(Unexpected::Str(v), &self))
         }
     }
 
diff --git a/src/de.rs b/src/de.rs
index 2b20a09..7157ff0 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -4,7 +4,7 @@ use std::io::{Read, Seek};
 use std::iter::Peekable;
 
 use events::{self, Event};
-use {u64_option_to_usize, Error};
+use {u64_to_usize, Error};
 
 macro_rules! expect {
     ($next:expr, $pat:pat) => {
@@ -73,7 +73,7 @@ where
     {
         match try_next!(self.events.next()) {
             Event::StartArray(len) => {
-                let len = u64_option_to_usize(len)?;
+                let len = len.and_then(u64_to_usize);
                 let ret = visitor.visit_seq(MapAndSeqAccess::new(self, false, len))?;
                 expect!(self.events.next(), Event::EndArray);
                 Ok(ret)
@@ -81,7 +81,7 @@ where
             Event::EndArray => Err(event_mismatch_error()),
 
             Event::StartDictionary(len) => {
-                let len = u64_option_to_usize(len)?;
+                let len = len.and_then(u64_to_usize);
                 let ret = visitor.visit_map(MapAndSeqAccess::new(self, false, len))?;
                 expect!(self.events.next(), Event::EndDictionary);
                 Ok(ret)
diff --git a/src/events/binary_reader.rs b/src/events/binary_reader.rs
index 81af922..6068545 100644
--- a/src/events/binary_reader.rs
+++ b/src/events/binary_reader.rs
@@ -165,7 +165,7 @@ impl<R: Read + Seek> BinaryReader<R> {
     }
 
     fn seek_to_object(&mut self, object_ref: u64) -> Result<u64, Error> {
-        let object_ref = u64_to_usize(object_ref)?;
+        let object_ref = u64_to_usize(object_ref).ok_or(Error::InvalidData)?;
         let offset = *self
             .object_offsets
             .get(object_ref)
@@ -232,9 +232,9 @@ impl<R: Read + Seek> BinaryReader<R> {
             (0x3, 3) => {
                 // Date. Seconds since 1/1/2001 00:00:00.
                 let secs = self.reader.read_f64::<BigEndian>()?;
-                Some(Event::DateValue(Date::from_seconds_since_plist_epoch(
-                    secs,
-                )?))
+                Some(Event::DateValue(
+                    Date::from_seconds_since_plist_epoch(secs).map_err(|()| Error::InvalidData)?,
+                ))
             }
             (0x4, n) => {
                 // Data
diff --git a/src/events/xml_reader.rs b/src/events/xml_reader.rs
index 6bb9936..fb09864 100644
--- a/src/events/xml_reader.rs
+++ b/src/events/xml_reader.rs
@@ -74,11 +74,11 @@ impl<R: Read> XmlReader<R> {
                             }))
                         }
                         "date" => {
-                            return Some(
-                                self.read_content(|s| {
-                                    Ok(Event::DateValue(Date::from_rfc3339(&s)?))
-                                }),
-                            )
+                            return Some(self.read_content(|s| {
+                                Ok(Event::DateValue(
+                                    Date::from_rfc3339(&s).map_err(|()| Error::InvalidData)?,
+                                ))
+                            }))
                         }
                         "integer" => {
                             return Some(self.read_content(|s| match FromStr::from_str(&s) {
diff --git a/src/lib.rs b/src/lib.rs
index e1a0985..3178ee4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -129,17 +129,10 @@ impl From<io::Error> for Error {
     }
 }
 
-fn u64_to_usize(len_u64: u64) -> Result<usize, Error> {
+fn u64_to_usize(len_u64: u64) -> Option<usize> {
     let len = len_u64 as usize;
     if len as u64 != len_u64 {
-        return Err(Error::InvalidData); // Too long
-    }
-    Ok(len)
-}
-
-fn u64_option_to_usize(len: Option<u64>) -> Result<Option<usize>, Error> {
-    match len {
-        Some(len) => Ok(Some(u64_to_usize(len)?)),
-        None => Ok(None),
+        return None; // Too long
     }
+    Some(len)
 }
diff --git a/src/ser.rs b/src/ser.rs
index a1b9453..f20ab13 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -475,7 +475,7 @@ impl<'a, W: Writer> ser::Serializer for DateSerializer<'a, W> {
     }
 
     fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
-        let date = Date::from_rfc3339(v).map_err(|_| self.expecting_date_error())?;
+        let date = Date::from_rfc3339(v).map_err(|()| self.expecting_date_error())?;
         self.ser.emit(Event::DateValue(date))
     }
 
diff --git a/src/value.rs b/src/value.rs
index 237ecdf..59cc3d3 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek};
 
 use events::{Event, Reader};
-use {u64_option_to_usize, Date, Error};
+use {u64_to_usize, Date, Error};
 
 /// Represents any plist value.
 #[derive(Clone, Debug, PartialEq)]
@@ -403,8 +403,7 @@ impl<T: Iterator<Item = Result<Event, Error>>> Builder<T> {
     }
 
     fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Value>, Error> {
-        let len = u64_option_to_usize(len)?;
-        let mut values = match len {
+        let mut values = match len.and_then(u64_to_usize) {
             Some(len) => Vec::with_capacity(len),
             None => Vec::new(),
         };