grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

updated serde to version 1.0

Browse Source
This commit is contained in:
debris
2017-07-06 11:36:15 +02:00
parent cc718bb108
commit 61d8f90530
116 changed files with 553 additions and 662 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ethstore/src/json/bytes.rs
View File

@@ -17,7 +17,7 @@
use std::{ops, str};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use rustc_serialize::hex::{ToHex, FromHex, FromHexError};
use rustc_hex::{ToHex, FromHex, FromHexError};
#[derive(Debug, PartialEq)]
pub struct Bytes(Vec<u8>);
@@ -30,9 +30,9 @@ impl ops::Deref for Bytes {
}
}
impl Deserialize for Bytes {
impl<'a> Deserialize<'a> for Bytes {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer
where D: Deserializer<'a>
{
let s = String::deserialize(deserializer)?;
let data = s.from_hex().map_err(|e| Error::custom(format!("Invalid hex value {}", e)))?;

12
ethstore/src/json/cipher.rs
View File

@@ -33,16 +33,16 @@ impl Serialize for CipherSer {
}
}
impl Deserialize for CipherSer {
impl<'a> Deserialize<'a> for CipherSer {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
deserializer.deserialize(CipherSerVisitor)
where D: Deserializer<'a> {
deserializer.deserialize_any(CipherSerVisitor)
}
}
struct CipherSerVisitor;
impl Visitor for CipherSerVisitor {
impl<'a> Visitor<'a> for CipherSerVisitor {
type Value = CipherSer;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -80,9 +80,9 @@ impl Serialize for CipherSerParams {
}
}
impl Deserialize for CipherSerParams {
impl<'a> Deserialize<'a> for CipherSerParams {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
where D: Deserializer<'a> {
Aes128Ctr::deserialize(deserializer)
.map(CipherSerParams::Aes128Ctr)
.map_err(|_| Error::InvalidCipherParams)

32
ethstore/src/json/crypto.rs
View File

@@ -17,7 +17,7 @@
use std::{fmt, str};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::ser::SerializeStruct;
use serde::de::{Visitor, MapVisitor, Error};
use serde::de::{Visitor, MapAccess, Error};
use serde_json;
use super::{Cipher, CipherSer, CipherSerParams, Kdf, KdfSer, KdfSerParams, H256, Bytes};
@@ -54,17 +54,17 @@ enum CryptoField {
Mac,
}
impl Deserialize for CryptoField {
impl<'a> Deserialize<'a> for CryptoField {
fn deserialize<D>(deserializer: D) -> Result<CryptoField, D::Error>
where D: Deserializer
where D: Deserializer<'a>
{
deserializer.deserialize(CryptoFieldVisitor)
deserializer.deserialize_any(CryptoFieldVisitor)
}
}
struct CryptoFieldVisitor;
impl Visitor for CryptoFieldVisitor {
impl<'a> Visitor<'a> for CryptoFieldVisitor {
type Value = CryptoField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -86,9 +86,9 @@ impl Visitor for CryptoFieldVisitor {
}
}
impl Deserialize for Crypto {
impl<'a> Deserialize<'a> for Crypto {
fn deserialize<D>(deserializer: D) -> Result<Crypto, D::Error>
where D: Deserializer
where D: Deserializer<'a>
{
static FIELDS: &'static [&'static str] = &["id", "version", "crypto", "Crypto", "address"];
deserializer.deserialize_struct("Crypto", FIELDS, CryptoVisitor)
@@ -97,7 +97,7 @@ impl Deserialize for Crypto {
struct CryptoVisitor;
impl Visitor for CryptoVisitor {
impl<'a> Visitor<'a> for CryptoVisitor {
type Value = Crypto;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -105,7 +105,7 @@ impl Visitor for CryptoVisitor {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where V: MapVisitor
where V: MapAccess<'a>
{
let mut cipher = None;
let mut cipherparams = None;
@@ -115,13 +115,13 @@ impl Visitor for CryptoVisitor {
let mut mac = None;
loop {
match visitor.visit_key()? {
Some(CryptoField::Cipher) => { cipher = Some(visitor.visit_value()?); }
Some(CryptoField::CipherParams) => { cipherparams = Some(visitor.visit_value()?); }
Some(CryptoField::CipherText) => { ciphertext = Some(visitor.visit_value()?); }
Some(CryptoField::Kdf) => { kdf = Some(visitor.visit_value()?); }
Some(CryptoField::KdfParams) => { kdfparams = Some(visitor.visit_value()?); }
Some(CryptoField::Mac) => { mac = Some(visitor.visit_value()?); }
match visitor.next_key()? {
Some(CryptoField::Cipher) => { cipher = Some(visitor.next_value()?); }
Some(CryptoField::CipherParams) => { cipherparams = Some(visitor.next_value()?); }
Some(CryptoField::CipherText) => { ciphertext = Some(visitor.next_value()?); }
Some(CryptoField::Kdf) => { kdf = Some(visitor.next_value()?); }
Some(CryptoField::KdfParams) => { kdfparams = Some(visitor.next_value()?); }
Some(CryptoField::Mac) => { mac = Some(visitor.next_value()?); }
None => { break; }
}
}

10
ethstore/src/json/hash.rs
View File

@@ -15,7 +15,7 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::{ops, fmt, str};
use rustc_serialize::hex::{FromHex, ToHex};
use rustc_hex::{FromHex, ToHex};
use serde::{Serialize, Serializer, Deserialize, Deserializer};
use serde::de::{Visitor, Error as SerdeError};
use super::Error;
@@ -54,12 +54,12 @@ macro_rules! impl_hash {
}
}
impl Deserialize for $name {
impl<'a> Deserialize<'a> for $name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
where D: Deserializer<'a> {
struct HashVisitor;
impl Visitor for HashVisitor {
impl<'b> Visitor<'b> for HashVisitor {
type Value = $name;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -75,7 +75,7 @@ macro_rules! impl_hash {
}
}
deserializer.deserialize(HashVisitor)
deserializer.deserialize_any(HashVisitor)
}
}

10
ethstore/src/json/id.rs
View File

@@ -16,7 +16,7 @@
//! Universaly unique identifier.
use std::{fmt, str};
use rustc_serialize::hex::{ToHex, FromHex};
use rustc_hex::{ToHex, FromHex};
use serde::{Deserialize, Serialize, Deserializer, Serializer};
use serde::de::{Visitor, Error as SerdeError};
use super::Error;
@@ -108,16 +108,16 @@ impl Serialize for Uuid {
}
}
impl Deserialize for Uuid {
impl<'a> Deserialize<'a> for Uuid {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
deserializer.deserialize(UuidVisitor)
where D: Deserializer<'a> {
deserializer.deserialize_any(UuidVisitor)
}
}
struct UuidVisitor;
impl Visitor for UuidVisitor {
impl<'a> Visitor<'a> for UuidVisitor {
type Value = Uuid;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

20
ethstore/src/json/kdf.rs
View File

@@ -35,16 +35,16 @@ impl Serialize for KdfSer {
}
}
impl Deserialize for KdfSer {
impl<'a> Deserialize<'a> for KdfSer {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
deserializer.deserialize(KdfSerVisitor)
where D: Deserializer<'a> {
deserializer.deserialize_any(KdfSerVisitor)
}
}
struct KdfSerVisitor;
impl Visitor for KdfSerVisitor {
impl<'a> Visitor<'a> for KdfSerVisitor {
type Value = KdfSer;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -78,16 +78,16 @@ impl Serialize for Prf {
}
}
impl Deserialize for Prf {
impl<'a> Deserialize<'a> for Prf {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
deserializer.deserialize(PrfVisitor)
where D: Deserializer<'a> {
deserializer.deserialize_any(PrfVisitor)
}
}
struct PrfVisitor;
impl Visitor for PrfVisitor {
impl<'a> Visitor<'a> for PrfVisitor {
type Value = Prf;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -139,9 +139,9 @@ impl Serialize for KdfSerParams {
}
}
impl Deserialize for KdfSerParams {
impl<'a> Deserialize<'a> for KdfSerParams {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer {
where D: Deserializer<'a> {
use serde_json::{Value, from_value};
let v: Value = Deserialize::deserialize(deserializer)?;

36
ethstore/src/json/key_file.rs
View File

@@ -17,7 +17,7 @@
use std::fmt;
use std::io::{Read, Write};
use serde::{Serialize, Serializer, Deserialize, Deserializer};
use serde::de::{Error, Visitor, MapVisitor};
use serde::de::{Error, Visitor, MapAccess, DeserializeOwned};
use serde_json;
use super::{Uuid, Version, Crypto, H160};
@@ -60,17 +60,17 @@ enum KeyFileField {
Meta,
}
impl Deserialize for KeyFileField {
impl<'a> Deserialize<'a> for KeyFileField {
fn deserialize<D>(deserializer: D) -> Result<KeyFileField, D::Error>
where D: Deserializer
where D: Deserializer<'a>
{
deserializer.deserialize(KeyFileFieldVisitor)
deserializer.deserialize_any(KeyFileFieldVisitor)
}
}
struct KeyFileFieldVisitor;
impl Visitor for KeyFileFieldVisitor {
impl<'a> Visitor<'a> for KeyFileFieldVisitor {
type Value = KeyFileField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -93,9 +93,9 @@ impl Visitor for KeyFileFieldVisitor {
}
}
impl Deserialize for KeyFile {
impl<'a> Deserialize<'a> for KeyFile {
fn deserialize<D>(deserializer: D) -> Result<KeyFile, D::Error>
where D: Deserializer
where D: Deserializer<'a>
{
static FIELDS: &'static [&'static str] = &["id", "version", "crypto", "Crypto", "address"];
deserializer.deserialize_struct("KeyFile", FIELDS, KeyFileVisitor)
@@ -103,8 +103,8 @@ impl Deserialize for KeyFile {
}
fn none_if_empty<T>(v: Option<serde_json::Value>) -> Option<T> where
T: Deserialize,
fn none_if_empty<'a, T>(v: Option<serde_json::Value>) -> Option<T> where
T: DeserializeOwned
{
v.and_then(|v| if v.is_null() {
None
@@ -115,7 +115,7 @@ fn none_if_empty<T>(v: Option<serde_json::Value>) -> Option<T> where
}
struct KeyFileVisitor;
impl Visitor for KeyFileVisitor {
impl<'a> Visitor<'a> for KeyFileVisitor {
type Value = KeyFile;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -123,7 +123,7 @@ impl Visitor for KeyFileVisitor {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where V: MapVisitor
where V: MapAccess<'a>
{
let mut id = None;
let mut version = None;
@@ -133,13 +133,13 @@ impl Visitor for KeyFileVisitor {
let mut meta = None;
loop {
match visitor.visit_key()? {
Some(KeyFileField::Id) => { id = Some(visitor.visit_value()?); }
Some(KeyFileField::Version) => { version = Some(visitor.visit_value()?); }
Some(KeyFileField::Crypto) => { crypto = Some(visitor.visit_value()?); }
Some(KeyFileField::Address) => { address = Some(visitor.visit_value()?); }
Some(KeyFileField::Name) => { name = none_if_empty(visitor.visit_value().ok()) }
Some(KeyFileField::Meta) => { meta = none_if_empty(visitor.visit_value().ok()) }
match visitor.next_key()? {
Some(KeyFileField::Id) => { id = Some(visitor.next_value()?); }
Some(KeyFileField::Version) => { version = Some(visitor.next_value()?); }
Some(KeyFileField::Crypto) => { crypto = Some(visitor.next_value()?); }
Some(KeyFileField::Address) => { address = Some(visitor.next_value()?); }
Some(KeyFileField::Name) => { name = none_if_empty(visitor.next_value().ok()) }
Some(KeyFileField::Meta) => { meta = none_if_empty(visitor.next_value().ok()) }
None => { break; }
}
}

8
ethstore/src/json/version.rs
View File

@@ -33,16 +33,16 @@ impl Serialize for Version {
}
}
impl Deserialize for Version {
impl<'a> Deserialize<'a> for Version {
fn deserialize<D>(deserializer: D) -> Result<Version, D::Error>
where D: Deserializer {
deserializer.deserialize(VersionVisitor)
where D: Deserializer<'a> {
deserializer.deserialize_any(VersionVisitor)
}
}
struct VersionVisitor;
impl Visitor for VersionVisitor {
impl<'a> Visitor<'a> for VersionVisitor {
type Value = Version;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {