utils compilable in beta

util/Cargo.toml

@@ -6,9 +6,6 @@ name = "ethcore-util"
 version = "0.9.99"
 authors = ["Ethcore <admin@ethcore.io>"]
 
-[features]
-default = [ "heapsize/nightly" ]
-
 [dependencies]
 log = "0.3"
 env_logger = "0.3"
@@ -36,4 +33,4 @@ igd = "0.4.2"
 
 [features]
 default = []
-dev = ["clippy"]
+dev = ["clippy"]

util/src/hash.rs

@@ -413,15 +413,6 @@ macro_rules! impl_hash {
 			}
 		}
 
-		/// Moving BitOrAssign
-		impl<'a> BitOrAssign<&'a $from> for $from {
-			fn bitor_assign(&mut self, rhs: &'a Self) {
-				for i in 0..$size {
-					self.0[i] = self.0[i] | rhs.0[i];
-				}
-			}
-		}
-
 		/// BitAnd on references
 		impl <'a> BitAnd for &'a $from {
 			type Output = $from;

util/src/lib.rs

@@ -15,12 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 #![warn(missing_docs)]
-#![feature(op_assign_traits)]
-#![feature(augmented_assignments)]
-#![feature(associated_consts)]
 #![cfg_attr(feature="dev", feature(plugin))]
 #![cfg_attr(feature="dev", plugin(clippy))]
-#![feature(catch_panic)]
 // Clippy settings
 // TODO [todr] not really sure
 #![allow(needless_range_loop)]

util/src/panics.rs

@@ -40,6 +40,18 @@ pub trait MayPanic {
 	fn on_panic<F>(&self, closure: F) where F: OnPanicListener;
 }
 
+struct PanicGuard<'a> {
+	handler: &'a PanicHandler,
+}
+
+impl<'a> Drop for PanicGuard<'a> {
+	fn drop(&mut self) {
+		if thread::panicking() {
+			self.handler.notify_all("Panic!".to_owned());
+		}
+	}
+}
+
 /// Structure that allows to catch panics and notify listeners
 pub struct PanicHandler {
 	listeners: Mutex<Vec<Box<OnPanicListener>>>
@@ -63,16 +75,9 @@ impl PanicHandler {
 	#[allow(deprecated)]
 	// TODO [todr] catch_panic is deprecated but panic::recover has different bounds (not allowing mutex)
 	pub fn catch_panic<G, R>(&self, g: G) -> thread::Result<R> where G: FnOnce() -> R + Send + 'static {
-		let result = thread::catch_panic(g);
-
-		if let Err(ref e) = result {
-			let res = convert_to_string(e);
-			if let Some(r) = res {
-				self.notify_all(r);
-			}
-		}
-
-		result
+		let guard = PanicGuard { handler: self };
+		let result = g();
+		Ok(result)
 	}
 
 	fn notify_all(&self, r: String) {

util/src/rlp/bytes.rs

@@ -232,12 +232,12 @@ impl_uint_from_bytes!(u64);
 impl_uint_from_bytes!(usize);
 
 macro_rules! impl_uint_from_bytes {
-	($name: ident) => {
+	($name: ident, $size: expr) => {
 		impl FromBytes for $name {
 			fn from_bytes(bytes: &[u8]) -> FromBytesResult<$name> {
 				if !bytes.is_empty() && bytes[0] == 0 {
 					Err(FromBytesError::ZeroPrefixedInt)
-				} else if bytes.len() <= $name::SIZE {
+				} else if bytes.len() <= $size {
 					Ok($name::from(bytes))
 				} else {
 					Err(FromBytesError::DataIsTooLong)
@@ -247,8 +247,8 @@ macro_rules! impl_uint_from_bytes {
 	}
 }
 
-impl_uint_from_bytes!(U256);
-impl_uint_from_bytes!(U128);
+impl_uint_from_bytes!(U256, 256);
+impl_uint_from_bytes!(U128, 128);
 
 impl <T>FromBytes for T where T: FixedHash {
 	fn from_bytes(bytes: &[u8]) -> FromBytesResult<T> {

util/src/rlp/untrusted_rlp.rs

@@ -429,7 +429,6 @@ impl<T> Decodable for Option<T> where T: Decodable {
 macro_rules! impl_array_decodable {
 	($index_type:ty, $len:expr ) => (
 		impl<T> Decodable for [T; $len] where T: Decodable {
-			#[allow(len_zero)]
 			fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
 				let decoders = decoder.as_rlp();
 

util/src/uint.rs

@@ -78,9 +78,6 @@ macro_rules! panic_on_overflow {
 /// Large, fixed-length unsigned integer type.
 pub trait Uint: Sized + Default + FromStr + From<u64> + FromJson + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
 
-	/// Size of this type.
-	const SIZE: usize;
-
 	/// Returns new instance equalling zero.
 	fn zero() -> Self;
 	/// Returns new instance equalling one.
@@ -148,8 +145,6 @@ macro_rules! construct_uint {
 		pub struct $name(pub [u64; $n_words]);
 
 		impl Uint for $name {
-			const SIZE: usize = $n_words * 8;
-
 			type FromDecStrErr = FromHexError;
 
 			/// TODO: optimize, throw appropriate err
@@ -634,66 +629,6 @@ macro_rules! construct_uint {
 
 		// TODO: optimise and traitify.
 
-		impl<'a> AddAssign<&'a $name> for $name {
-			fn add_assign(&mut self, other: &'a Self) {
-				*self = self.add(*other);
-			}
-		}
-
-		impl<'a> SubAssign<&'a $name> for $name {
-			fn sub_assign(&mut self, other: &'a Self) {
-				*self = self.sub(*other);
-			}
-		}
-
-		impl<'a> MulAssign<&'a $name> for $name {
-			fn mul_assign(&mut self, other: &'a Self) {
-				*self = self.mul(*other);
-			}
-		}
-
-		impl<'a> DivAssign<&'a $name> for $name {
-			fn div_assign(&mut self, other: &'a Self) {
-				*self = self.div(*other);
-			}
-		}
-
-		impl<'a> RemAssign<&'a $name> for $name {
-			fn rem_assign(&mut self, other: &'a Self) {
-				*self = self.rem(*other);
-			}
-		}
-
-		impl AddAssign<$name> for $name {
-			fn add_assign(&mut self, other: Self) {
-				*self = self.add(other);
-			}
-		}
-
-		impl SubAssign<$name> for $name {
-			fn sub_assign(&mut self, other: Self) {
-				*self = self.sub(other);
-			}
-		}
-
-		impl MulAssign<$name> for $name {
-			fn mul_assign(&mut self, other: Self) {
-				*self = self.mul(other);
-			}
-		}
-
-		impl DivAssign<$name> for $name {
-			fn div_assign(&mut self, other: Self) {
-				*self = self.div(other);
-			}
-		}
-
-		impl RemAssign<$name> for $name {
-			fn rem_assign(&mut self, other: Self) {
-				*self = self.rem(other);
-			}
-		}
-
 		impl BitAnd<$name> for $name {
 			type Output = $name;
 
@@ -964,37 +899,6 @@ mod tests {
 	use uint::{Uint, U128, U256, U512};
 	use std::str::FromStr;
 
-	#[test]
-	pub fn assign_ops() {
-		let x: U256 = x!(69);
-		let y: U256 = x!(42);
-		{
-			let mut z = x;
-			z += y;
-			assert_eq!(z, x + y);
-		}
-		{
-			let mut z = x;
-			z -= y;
-			assert_eq!(z, x - y);
-		}
-		{
-			let mut z = x;
-			z *= y;
-			assert_eq!(z, x * y);
-		}
-		{
-			let mut z = x;
-			z /= y;
-			assert_eq!(z, x / y);
-		}
-		{
-			let mut z = x;
-			z %= y;
-			assert_eq!(z, x % y);
-		}
-	}
-
 	#[test]
 	pub fn uint256_from() {
 		let e = U256([10, 0, 0, 0]);