Add Error type

src/core_support.rs

@@ -13,13 +13,28 @@ use core::{fmt, str};
 use parser;
 use prelude::*;
 
+impl From<super::BytesError> for super::Error {
+    fn from(err: super::BytesError) -> Self {
+        super::Error::Bytes(err)
+    }
+}
+
 impl fmt::Debug for Uuid {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::LowerHex::fmt(self, f)
     }
 }
 
+impl fmt::Display for super::Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            super::Error::Bytes(ref err) => fmt::Display::fmt(&err, f),
+            super::Error::Parse(ref err) => fmt::Display::fmt(&err, f),
+        }
+    }
+}
+
 impl fmt::Display for Uuid {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::LowerHex::fmt(self, f)

src/lib.rs

@@ -218,6 +218,35 @@ pub struct BytesError {
     found: usize,
 }
 
+/// A general error that can occur when handling [`Uuid`]s.
+///
+/// Although specialized error types exist in the crate,
+/// sometimes where particular error type occurred is hidden
+/// until errors need to be handled. This allows to enumerate 
+/// the errors.
+///
+/// [`Uuid`]: struct.Uuid.html
+// TODO: improve the doc
+// BODY: This detail should be fine for initial merge
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum Error {
+    /// An error occurred while handling [`Uuid`] bytes.
+    ///
+    /// See [`BytesError`]
+    ///
+    /// [`BytesError`]: struct.BytesError.html
+    /// [`Uuid`]: struct.Uuid.html
+    Bytes(BytesError),
+
+    /// An error occurred while parsing a [`Uuid`] string.
+    ///
+    /// See [`parser::ParseError`]
+    ///
+    /// [`parser::ParseError`]: parser/enum.ParseError.html
+    /// [`Uuid`]: struct.Uuid.html
+    Parse(parser::ParseError),
+}
+
 /// The version of the UUID, denoting the generating algorithm.
 #[derive(Debug, PartialEq, Copy, Clone)]
 #[repr(C)]

src/parser/core_support.rs

@@ -12,6 +12,12 @@
 use core::fmt;
 use parser;
 
+impl From<parser::ParseError> for ::Error {
+    fn from(err: parser::ParseError) -> Self {
+        ::Error::Parse(err)
+    }
+}
+
 impl<'a> fmt::Display for parser::Expected {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {

src/prelude.rs

@@ -29,10 +29,11 @@
 //!
 //! Currently the prelude reexports the following:
 //!
-//! [`uuid`]`::{`[`Uuid`], [`Variant`], [`Version`], builder::[`Builder`]`}`:
+//! [`uuid`]`::{`[`Error`], [`Uuid`], [`Variant`], [`Version`], builder::[`Builder`]`}`:
 //! The fundamental types used in [`uuid`] crate.
 //!
 //! [`uuid`]: ../index.html
+//! [`Error`]: ../enum.Error.html
 //! [`Uuid`]: ../struct.Uuid.html
 //! [`Variant`]: ../enum.Variant.html
 //! [`Version`]: ../enum.Version.html

src/std_support.rs

@@ -11,8 +11,18 @@
 
 use std::error;
 
-impl error::Error for ::BytesError {
+impl error::Error for super::BytesError {
     fn description(&self) -> &str {
         "invalid number of uuid bytes"
     }
 }
+
+impl error::Error for super::Error {
+    fn description(&self) -> &str {
+        match *self {
+            super::Error::Bytes(ref err) => error::Error::description(err),
+            super::Error::Parse(ref err) => error::Error::description(err),
+        }
+    }
+}
+