poanetwork
/
parity-common
mirror of https://github.com/poanetwork/parity-common.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove serialize crate (replaced by serde) and use impl-serde in ethbloom

This commit is contained in:
Wei Tang 2018-12-02 22:34:58 +08:00
parent 9a698b8272
commit 1564dc1f63
4 changed files with 11 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ethbloom/Cargo.toml
View File

@ -11,9 +11,8 @@ repository = "https://github.com/paritytech/primitives"
[dependencies]
tiny-keccak = "1.4"
crunchy = { version = "0.2.1", default-features = false, features = ["limit_256"] }
fixed-hash = { version = "0.3", default_features = false }
ethereum-types-serialize = { version = "0.2.1", path = "../serialize", optional = true }
serde = { version = "1.0", optional = true }
fixed-hash = { version = "0.3", default-features = false }
impl-serde = { version = "0.1", default-features = false, optional = true }
[dev-dependencies]
rand = { version = "0.4" }
@ -23,4 +22,4 @@ hex-literal = "0.1.1"
default = ["std", "heapsize", "serialize", "fixed-hash/libc", "fixed-hash/rustc-hex"]
std = ["fixed-hash/std", "crunchy/std"]
heapsize = ["fixed-hash/heapsize"]
serialize = ["std", "ethereum-types-serialize", "serde"]
serialize = ["std", "impl-serde"]

35
ethbloom/src/lib.rs
View File

@ -1,4 +1,4 @@
//!
//!
//! ```rust
//! extern crate ethbloom;
//! #[macro_use] extern crate hex_literal;
@ -26,7 +26,7 @@
//! ).unwrap();
//! let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106");
//! let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc");
//!
//!
//! let mut my_bloom = Bloom::default();
//! assert!(!my_bloom.contains_input(Input::Raw(&address)));
//! assert!(!my_bloom.contains_input(Input::Raw(&topic)));
@ -34,7 +34,7 @@
//! my_bloom.accrue(Input::Raw(&address));
//! assert!(my_bloom.contains_input(Input::Raw(&address)));
//! assert!(!my_bloom.contains_input(Input::Raw(&topic)));
//!
//!
//! my_bloom.accrue(Input::Raw(&topic));
//! assert!(my_bloom.contains_input(Input::Raw(&address)));
//! assert!(my_bloom.contains_input(Input::Raw(&topic)));
@ -56,18 +56,13 @@ extern crate crunchy;
extern crate fixed_hash;
#[cfg(feature="serialize")]
extern crate ethereum_types_serialize;
#[cfg(feature="serialize")]
extern crate serde;
#[macro_use]
extern crate impl_serde;
#[cfg(test)]
#[macro_use]
extern crate hex_literal;
#[cfg(feature="serialize")]
use serde::{Serialize, Serializer, Deserialize, Deserializer};
use core::{ops, mem};
use tiny_keccak::keccak256;
@ -227,7 +222,7 @@ impl<'a> BloomRef<'a> {
let bloom: Bloom = input.into();
self.contains_bloom(&bloom)
}
pub fn contains_bloom<'b, B>(&self, bloom: B) -> bool where BloomRef<'b>: From<B> {
let bloom_ref: BloomRef = bloom.into();
assert_eq!(self.0.len(), BLOOM_SIZE);
@ -259,22 +254,8 @@ impl<'a> From<&'a Bloom> for BloomRef<'a> {
}
}
#[cfg(feature="serialize")]
impl Serialize for Bloom {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
let mut slice = [0u8; 2 + 2 * BLOOM_SIZE];
ethereum_types_serialize::serialize(&mut slice, &self.0, serializer)
}
}
#[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for Bloom {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
let mut bytes = [0; BLOOM_SIZE];
ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Exact(&mut bytes))?;
Ok(Bloom(bytes))
}
}
#[cfg(feature = "serialize")]
impl_fixed_hash_serde!(Bloom, BLOOM_SIZE);
#[cfg(test)]
mod tests {

10
serialize/Cargo.toml
View File

@ -1,10 +0,0 @@
[package]
name = "ethereum-types-serialize"
version = "0.2.1"
authors = ["Parity Technologies <admin@parity.io>"]
license = "MIT"
homepage = "https://github.com/paritytech/primitives"
description = "Ethereum types"
[dependencies]
serde = "1.0"

144
serialize/src/lib.rs
View File

@ -1,144 +0,0 @@
extern crate serde;
use std::fmt;
use serde::{de, Serializer, Deserializer};
static CHARS: &'static[u8] = b"0123456789abcdef";
fn to_hex<'a>(v: &'a mut [u8], bytes: &[u8], skip_leading_zero: bool) -> &'a str {
assert!(v.len() > 1 + bytes.len() * 2);
v[0] = b'0';
v[1] = b'x';
let mut idx = 2;
let first_nibble = bytes[0] >> 4;
if first_nibble != 0 || !skip_leading_zero {
v[idx] = CHARS[first_nibble as usize];
idx += 1;
}
v[idx] = CHARS[(bytes[0] & 0xf) as usize];
idx += 1;
for &byte in bytes.iter().skip(1) {
v[idx] = CHARS[(byte >> 4) as usize];
v[idx + 1] = CHARS[(byte & 0xf) as usize];
idx += 2;
}
::std::str::from_utf8(&v[0..idx]).expect("All characters are coming from CHARS")
}
/// Serializes a slice of bytes.
pub fn serialize<S>(slice: &mut [u8], bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
{
serializer.serialize_str(to_hex(slice, bytes, false))
}
/// Serialize a slice of bytes as uint.
///
/// The representation will have all leading zeros trimmed.
pub fn serialize_uint<S>(slice: &mut [u8], bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
{
let non_zero = bytes.iter().take_while(|b| **b == 0).count();
let bytes = &bytes[non_zero..];
if bytes.is_empty() {
return serializer.serialize_str("0x0");
}
serializer.serialize_str(to_hex(slice, bytes, true))
}
/// Expected length of bytes vector.
#[derive(Debug, PartialEq, Eq)]
pub enum ExpectedLen<'a> {
/// Exact length in bytes.
Exact(&'a mut [u8]),
/// A bytes length between (min; slice.len()].
Between(usize, &'a mut [u8]),
}
impl<'a> fmt::Display for ExpectedLen<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExpectedLen::Exact(ref v) => write!(fmt, "length of {}", v.len() * 2),
ExpectedLen::Between(min, ref v) => write!(fmt, "length between ({}; {}]", min * 2, v.len() * 2),
}
}
}
/// Deserialize into vector of bytes with additional size check.
/// Returns number of bytes written.
pub fn deserialize_check_len<'a, 'de, D>(deserializer: D, len: ExpectedLen<'a>) -> Result<usize, D::Error> where
D: Deserializer<'de>,
{
struct Visitor<'a> {
len: ExpectedLen<'a>,
}
impl<'a, 'b> de::Visitor<'b> for Visitor<'a> {
type Value = usize;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "a 0x-prefixed hex string with {}", self.len)
}
fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
if v.len() < 2 || &v[0..2] != "0x" {
return Err(E::custom("prefix is missing"))
}
let is_len_valid = match self.len {
ExpectedLen::Exact(ref slice) => v.len() == 2 * slice.len() + 2,
ExpectedLen::Between(min, ref slice) => v.len() <= 2 * slice.len() + 2 && v.len() > 2 * min + 2,
};
if !is_len_valid {
return Err(E::invalid_length(v.len() - 2, &self))
}
let bytes = match self.len {
ExpectedLen::Exact(slice) => slice,
ExpectedLen::Between(_, slice) => slice,
};
let mut modulus = v.len() % 2;
let mut buf = 0;
let mut pos = 0;
for (idx, byte) in v.bytes().enumerate().skip(2) {
buf <<= 4;
match byte {
b'A'...b'F' => buf |= byte - b'A' + 10,
b'a'...b'f' => buf |= byte - b'a' + 10,
b'0'...b'9' => buf |= byte - b'0',
b' '|b'\r'|b'\n'|b'\t' => {
buf >>= 4;
continue
}
_ => {
let ch = v[idx..].chars().next().unwrap();
return Err(E::custom(&format!("invalid hex character: {}, at {}", ch, idx)))
}
}
modulus += 1;
if modulus == 2 {
modulus = 0;
bytes[pos] = buf;
pos += 1;
}
}
Ok(pos)
}
fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> {
self.visit_str(&v)
}
}
deserializer.deserialize_str(Visitor { len })
}