UtilError uses error_chain!, moved OutOfBounds and Mismatched to unexpected crate

util/Cargo.toml

@@ -34,6 +34,7 @@ regex = "0.2"
 lru-cache = "0.1.0"
 ethcore-logger = { path = "../logger" }
 triehash = { path = "triehash" }
+error-chain = "0.11.0-rc.2"
 
 [features]
 default = []

util/src/error.rs

@@ -16,9 +16,12 @@
 
 //! General error types for use in ethcore.
 
+#![allow(missing_docs)]
+#![allow(unknown_lints)]
+
+use std::{self, fmt};
 use rustc_hex::FromHexError;
 use rlp::DecoderError;
-use std::fmt;
 use bigint::hash::H256;
 
 #[derive(Debug)]
@@ -41,124 +44,23 @@ impl fmt::Display for BaseDataError {
 	}
 }
 
-#[derive(Debug)]
-/// General error type which should be capable of representing all errors in ethcore.
-pub enum UtilError {
-	/// Error concerning the Rust standard library's IO subsystem.
-	StdIo(::std::io::Error),
-	/// Error concerning the hex conversion logic.
-	FromHex(FromHexError),
-	/// Error concerning the database abstraction logic.
-	BaseData(BaseDataError),
-	/// Error concerning the RLP decoder.
-	Decoder(DecoderError),
-	/// Miscellaneous error described by a string.
-	SimpleString(String),
-	/// Error from a bad input size being given for the needed output.
-	BadSize,
-	/// Error from snappy.
-	Snappy(::snappy::InvalidInput),
-}
-
-impl fmt::Display for UtilError {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		match *self {
-			UtilError::StdIo(ref err) => f.write_fmt(format_args!("{}", err)),
-			UtilError::FromHex(ref err) => f.write_fmt(format_args!("{}", err)),
-			UtilError::BaseData(ref err) => f.write_fmt(format_args!("{}", err)),
-			UtilError::Decoder(ref err) => f.write_fmt(format_args!("{}", err)),
-			UtilError::SimpleString(ref msg) => f.write_str(msg),
-			UtilError::BadSize => f.write_str("Bad input size."),
-			UtilError::Snappy(ref err) => f.write_fmt(format_args!("{}", err)),
-		}
+impl std::error::Error for BaseDataError {
+	fn description(&self) -> &str {
+		"Error in database subsystem"
 	}
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-/// Error indicating an expected value was not found.
-pub struct Mismatch<T: fmt::Debug> {
-	/// Value expected.
-	pub expected: T,
-	/// Value found.
-	pub found: T,
-}
+error_chain! {
+	types {
+		UtilError, ErrorKind, ResultExt, Result;
+	}
 
-impl<T: fmt::Debug + fmt::Display> fmt::Display for Mismatch<T> {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		f.write_fmt(format_args!("Expected {}, found {}", self.expected, self.found))
+	foreign_links {
+		Io(::std::io::Error);
+		FromHex(FromHexError);
+		Decoder(DecoderError);
+		Snappy(::snappy::InvalidInput);
+		BaseData(BaseDataError);
 	}
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-/// Error indicating value found is outside of a valid range.
-pub struct OutOfBounds<T: fmt::Debug> {
-	/// Minimum allowed value.
-	pub min: Option<T>,
-	/// Maximum allowed value.
-	pub max: Option<T>,
-	/// Value found.
-	pub found: T,
-}
-
-impl<T: fmt::Debug + fmt::Display> fmt::Display for OutOfBounds<T> {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		let msg = match (self.min.as_ref(), self.max.as_ref()) {
-			(Some(min), Some(max)) => format!("Min={}, Max={}", min, max),
-			(Some(min), _) => format!("Min={}", min),
-			(_, Some(max)) => format!("Max={}", max),
-			(None, None) => "".into(),
-		};
-
-		f.write_fmt(format_args!("Value {} out of bounds. {}", self.found, msg))
-	}
-}
-
-impl From<FromHexError> for UtilError {
-	fn from(err: FromHexError) -> UtilError {
-		UtilError::FromHex(err)
-	}
-}
-
-impl From<BaseDataError> for UtilError {
-	fn from(err: BaseDataError) -> UtilError {
-		UtilError::BaseData(err)
-	}
-}
-
-impl From<::std::io::Error> for UtilError {
-	fn from(err: ::std::io::Error) -> UtilError {
-		UtilError::StdIo(err)
-	}
-}
-
-impl From<::rlp::DecoderError> for UtilError {
-	fn from(err: ::rlp::DecoderError) -> UtilError {
-		UtilError::Decoder(err)
-	}
-}
-
-impl From<String> for UtilError {
-	fn from(err: String) -> UtilError {
-		UtilError::SimpleString(err)
-	}
-}
-
-impl From<::snappy::InvalidInput> for UtilError {
-	fn from(err: ::snappy::InvalidInput) -> UtilError {
-		UtilError::Snappy(err)
-	}
-}
-
-// TODO: uncomment below once https://github.com/rust-lang/rust/issues/27336 sorted.
-/*#![feature(concat_idents)]
-macro_rules! assimilate {
-    ($name:ident) => (
-		impl From<concat_idents!($name, Error)> for Error {
-			fn from(err: concat_idents!($name, Error)) -> Error {
-				Error:: $name (err)
-			}
-		}
-    )
-}
-assimilate!(FromHex);
-assimilate!(BaseData);*/

util/src/journaldb/archivedb.rs

@@ -26,7 +26,8 @@ use super::{DB_PREFIX_LEN, LATEST_ERA_KEY};
 use super::traits::JournalDB;
 use kvdb::{KeyValueDB, DBTransaction};
 use bigint::hash::H256;
-use {Bytes, BaseDataError, UtilError};
+use error::{BaseDataError, UtilError};
+use {Bytes};
 
 /// Implementation of the `HashDB` trait for a disk-backed database with a memory overlay
 /// and latent-removal semantics.

util/src/journaldb/earlymergedb.rs

@@ -29,7 +29,8 @@ use super::{DB_PREFIX_LEN, LATEST_ERA_KEY};
 use super::traits::JournalDB;
 use kvdb::{KeyValueDB, DBTransaction};
 use bigint::hash::H256;
-use { BaseDataError, UtilError, Bytes};
+use error::{BaseDataError, UtilError};
+use {Bytes};
 
 #[derive(Clone, PartialEq, Eq)]
 struct RefInfo {

util/src/journaldb/overlayrecentdb.rs

@@ -28,7 +28,8 @@ use super::{DB_PREFIX_LEN, LATEST_ERA_KEY};
 use kvdb::{KeyValueDB, DBTransaction};
 use super::JournalDB;
 use bigint::hash::{H256, H256FastMap};
-use {BaseDataError, UtilError, Bytes};
+use error::{BaseDataError, UtilError};
+use {Bytes};
 
 /// Implementation of the `JournalDB` trait for a disk-backed database with a memory overlay
 /// and, possibly, latent-removal semantics.

util/src/kvdb.rs

@@ -279,7 +279,7 @@ impl KeyValueDB for InMemory {
 	}
 
 	fn restore(&self, _new_db: &str) -> Result<(), UtilError> {
-		Err(UtilError::SimpleString("Attempted to restore in-memory database".into()))
+		Err("Attempted to restore in-memory database".into())
 	}
 }
 

util/src/lib.rs

@@ -109,6 +109,9 @@ extern crate heapsize;
 extern crate ethcore_logger;
 extern crate hash as keccak;
 
+#[macro_use]
+extern crate error_chain;
+
 #[macro_use]
 extern crate log as rlog;
 
@@ -136,7 +139,7 @@ pub use overlaydb::*;
 pub use journaldb::JournalDB;
 pub use trie::{Trie, TrieMut, TrieDB, TrieDBMut, TrieFactory, TrieError, SecTrieDB, SecTrieDBMut};
 pub use kvdb::*;
-pub use error::*;
+pub use error::UtilError;
 pub use bytes::*;
 
 /// 160-bit integer representing account address

util/src/overlaydb.rs

@@ -19,7 +19,7 @@
 use std::sync::Arc;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
-use error::*;
+use error::{Result, BaseDataError};
 use bigint::hash::*;
 use rlp::*;
 use hashdb::*;
@@ -56,14 +56,14 @@ impl OverlayDB {
 
 	/// Commit all operations in a single batch.
 	#[cfg(test)]
-	pub fn commit(&mut self) -> Result<u32, UtilError> {
+	pub fn commit(&mut self) -> Result<u32> {
 		let mut batch = self.backing.transaction();
 		let res = self.commit_to_batch(&mut batch)?;
 		self.backing.write(batch).map(|_| res).map_err(|e| e.into())
 	}
 
 	/// Commit all operations to given batch.
-	pub fn commit_to_batch(&mut self, batch: &mut DBTransaction) -> Result<u32, UtilError> {
+	pub fn commit_to_batch(&mut self, batch: &mut DBTransaction) -> Result<u32> {
 		let mut ret = 0u32;
 		let mut deletes = 0usize;
 		for i in self.overlay.drain() {

util/src/snappy.rs

@@ -16,7 +16,7 @@
 
 //! Snappy compression bindings.
 
-use std::fmt;
+use std::{self, fmt};
 use libc::{c_char, c_int, size_t};
 
 const SNAPPY_OK: c_int = 0;
@@ -56,6 +56,12 @@ extern {
 #[derive(Debug)]
 pub struct InvalidInput;
 
+impl std::error::Error for InvalidInput {
+	fn description(&self) -> &str {
+		"Attempted snappy decompression with invalid input"
+	}
+}
+
 impl fmt::Display for InvalidInput {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		write!(f, "Attempted snappy decompression with invalid input")

util/unexpected/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "unexpected"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]

util/unexpected/src/lib.rs

@@ -0,0 +1,58 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Error utils
+
+use std::fmt;
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+/// Error indicating an expected value was not found.
+pub struct Mismatch<T> {
+	/// Value expected.
+	pub expected: T,
+	/// Value found.
+	pub found: T,
+}
+
+impl<T: fmt::Display> fmt::Display for Mismatch<T> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.write_fmt(format_args!("Expected {}, found {}", self.expected, self.found))
+	}
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+/// Error indicating value found is outside of a valid range.
+pub struct OutOfBounds<T> {
+	/// Minimum allowed value.
+	pub min: Option<T>,
+	/// Maximum allowed value.
+	pub max: Option<T>,
+	/// Value found.
+	pub found: T,
+}
+
+impl<T: fmt::Display> fmt::Display for OutOfBounds<T> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		let msg = match (self.min.as_ref(), self.max.as_ref()) {
+			(Some(min), Some(max)) => format!("Min={}, Max={}", min, max),
+			(Some(min), _) => format!("Min={}", min),
+			(_, Some(max)) => format!("Max={}", max),
+			(None, None) => "".into(),
+		};
+
+		f.write_fmt(format_args!("Value {} out of bounds. {}", self.found, msg))
+	}
+}