Core/grin
0
0
Fork 0
mirror of https://github.com/mimblewimble/grin.git synced 2025-02-01 17:01:09 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replace try! for ? (#1134)

Browse source 
* Replace try for ?
This commit is contained in:
Quentin Le Sceller 2018-06-04 12:05:49 -04:00 committed by GitHub
parent c34da9598d
commit 663733e72b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 92 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
chain/src/store.rs
View file

@ -20,12 +20,12 @@ use lru_cache::LruCache;
use util::secp::pedersen::Commitment; use util::secp::pedersen::Commitment;
use types::*;
use core::core::hash::{Hash, Hashed};
use core::core::{Block, BlockHeader};
use core::consensus::TargetError; use core::consensus::TargetError;
use core::core::hash::{Hash, Hashed};
use core::core::target::Difficulty; use core::core::target::Difficulty;
use core::core::{Block, BlockHeader};
use grin_store::{self, option_to_not_found, to_key, Error, u64_to_key}; use grin_store::{self, option_to_not_found, to_key, Error, u64_to_key};
use types::*;
const STORE_SUBPATH: &'static str = "chain"; const STORE_SUBPATH: &'static str = "chain";
@ -63,7 +63,7 @@ impl ChainStore for ChainKVStore {
} }
fn head_header(&self) -> Result<BlockHeader, Error> { fn head_header(&self) -> Result<BlockHeader, Error> {
self.get_block_header(&try!(self.head()).last_block_h) self.get_block_header(&self.head()?.last_block_h)
} }
fn save_head(&self, t: &Tip) -> Result<(), Error> { fn save_head(&self, t: &Tip) -> Result<(), Error> {

14
chain/src/types.rs
View file

@ -228,19 +228,19 @@ impl Tip {
/// Serialization of a tip, required to save to datastore. /// Serialization of a tip, required to save to datastore.
impl ser::Writeable for Tip { impl ser::Writeable for Tip {
fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), ser::Error> { fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
try!(writer.write_u64(self.height)); writer.write_u64(self.height)?;
try!(writer.write_fixed_bytes(&self.last_block_h)); writer.write_fixed_bytes(&self.last_block_h)?;
try!(writer.write_fixed_bytes(&self.prev_block_h)); writer.write_fixed_bytes(&self.prev_block_h)?;
self.total_difficulty.write(writer) self.total_difficulty.write(writer)
} }
} }
impl ser::Readable for Tip { impl ser::Readable for Tip {
fn read(reader: &mut ser::Reader) -> Result<Tip, ser::Error> { fn read(reader: &mut ser::Reader) -> Result<Tip, ser::Error> {
let height = try!(reader.read_u64()); let height = reader.read_u64()?;
let last = try!(Hash::read(reader)); let last = Hash::read(reader)?;
let prev = try!(Hash::read(reader)); let prev = Hash::read(reader)?;
let diff = try!(Difficulty::read(reader)); let diff = Difficulty::read(reader)?;
Ok(Tip { Ok(Tip {
height: height, height: height,
last_block_h: last, last_block_h: last,

6
core/src/core/pmmr.rs
View file

@ -1330,9 +1330,9 @@ mod test {
impl Writeable for TestElem { impl Writeable for TestElem {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
try!(writer.write_u32(self.0[0])); writer.write_u32(self.0[0])?;
try!(writer.write_u32(self.0[1])); writer.write_u32(self.0[1])?;
try!(writer.write_u32(self.0[2])); writer.write_u32(self.0[2])?;
writer.write_u32(self.0[3]) writer.write_u32(self.0[3])
} }
} }

42
core/src/macros.rs
View file

@ -19,33 +19,27 @@
/// around every map call. /// around every map call.
#[macro_export] #[macro_export]
macro_rules! map_vec { macro_rules! map_vec {
($thing:expr, $mapfn:expr ) => { ($thing:expr, $mapfn:expr) => {
$thing.iter() $thing.iter().map($mapfn).collect::<Vec<_>>();
.map($mapfn) };
.collect::<Vec<_>>();
}
} }
/// Same as map_vec when the map closure returns Results. Makes sure the /// Same as map_vec when the map closure returns Results. Makes sure the
/// results are "pushed up" and wraps with a try. /// results are "pushed up" and wraps with a try.
#[macro_export] #[macro_export]
macro_rules! try_map_vec { macro_rules! try_map_vec {
($thing:expr, $mapfn:expr ) => { ($thing:expr, $mapfn:expr) => {
try!($thing.iter() $thing.iter().map($mapfn).collect::<Result<Vec<_>, _>>()?;
.map($mapfn) };
.collect::<Result<Vec<_>, _>>());
}
} }
/// Eliminates some of the verbosity in having iter and collect /// Eliminates some of the verbosity in having iter and collect
/// around every filter_map call. /// around every filter_map call.
#[macro_export] #[macro_export]
macro_rules! filter_map_vec { macro_rules! filter_map_vec {
($thing:expr, $mapfn:expr ) => { ($thing:expr, $mapfn:expr) => {
$thing.iter() $thing.iter().filter_map($mapfn).collect::<Vec<_>>();
.filter_map($mapfn) };
.collect::<Vec<_>>();
}
} }
/// Allows the conversion of an expression that doesn't return anything to one /// Allows the conversion of an expression that doesn't return anything to one
@ -55,12 +49,10 @@ macro_rules! filter_map_vec {
/// println!(tee!(foo, foo.append(vec![3,4,5])) /// println!(tee!(foo, foo.append(vec![3,4,5]))
#[macro_export] #[macro_export]
macro_rules! tee { macro_rules! tee {
($thing:ident, $thing_expr:expr) => { ($thing:ident, $thing_expr:expr) => {{
{ $thing_expr;
$thing_expr; $thing
$thing }};
}
}
} }
/// Eliminate some of the boilerplate of deserialization (package ser) by /// Eliminate some of the boilerplate of deserialization (package ser) by
@ -70,8 +62,8 @@ macro_rules! tee {
/// let bar = try!(reader.read_u32()); /// let bar = try!(reader.read_u32());
/// let fixed_byte_var = try!(reader.read_fixed_bytes(64)); /// let fixed_byte_var = try!(reader.read_fixed_bytes(64));
/// Example after: /// Example after:
/// let (foo, bar, fixed_byte_var) = ser_multiread!(reader, read_u64, read_u32, /// let (foo, bar, fixed_byte_var) = ser_multiread!(reader, read_u64,
/// read_fixed_bytes(64)); /// read_u32, read_fixed_bytes(64));
#[macro_export] #[macro_export]
macro_rules! ser_multiread { macro_rules! ser_multiread {
($rdr:ident, $($read_call:ident $(($val:expr)),*),*) => { ($rdr:ident, $($read_call:ident $(($val:expr)),*),*) => {
@ -96,7 +88,7 @@ macro_rules! ser_multiwrite {
// don't seem to be able to define an Ord implementation for Hash due to // don't seem to be able to define an Ord implementation for Hash due to
// Ord being defined on all pointers, resorting to a macro instead // Ord being defined on all pointers, resorting to a macro instead
macro_rules! hashable_ord { macro_rules! hashable_ord {
($hashable: ident) => { ($hashable:ident) => {
impl Ord for $hashable { impl Ord for $hashable {
fn cmp(&self, other: &$hashable) -> Ordering { fn cmp(&self, other: &$hashable) -> Ordering {
self.hash().cmp(&other.hash()) self.hash().cmp(&other.hash())
@ -113,5 +105,5 @@ macro_rules! hashable_ord {
} }
} }
impl Eq for $hashable {} impl Eq for $hashable {}
} };
} }

4
core/src/pow/cuckoo.rs
View file

@ -188,8 +188,8 @@ impl Miner {
if us[0] == 0 { if us[0] == 0 {
continue; // ignore duplicate edges continue; // ignore duplicate edges
} }
let nu = try!(self.path(u, &mut us)) as usize; let nu = self.path(u, &mut us)? as usize;
let nv = try!(self.path(v, &mut vs)) as usize; let nv = self.path(v, &mut vs)? as usize;
let sol = self.find_sol(nu, &us, nv, &vs); let sol = self.find_sol(nu, &us, nv, &vs);
match sol { match sol {

44
core/src/ser.rs
View file

@ -163,7 +163,7 @@ pub trait Writer {
/// Writes a variable number of bytes. The length is encoded as a 64-bit /// Writes a variable number of bytes. The length is encoded as a 64-bit
/// prefix. /// prefix.
fn write_bytes<T: AsFixedBytes>(&mut self, bytes: &T) -> Result<(), Error> { fn write_bytes<T: AsFixedBytes>(&mut self, bytes: &T) -> Result<(), Error> {
try!(self.write_u64(bytes.as_ref().len() as u64)); self.write_u64(bytes.as_ref().len() as u64)?;
self.write_fixed_bytes(bytes) self.write_fixed_bytes(bytes)
} }
@ -258,7 +258,7 @@ pub fn serialize<W: Writeable>(sink: &mut Write, thing: &W) -> Result<(), Error>
/// Vec<u8>. /// Vec<u8>.
pub fn ser_vec<W: Writeable>(thing: &W) -> Result<Vec<u8>, Error> { pub fn ser_vec<W: Writeable>(thing: &W) -> Result<Vec<u8>, Error> {
let mut vec = Vec::new(); let mut vec = Vec::new();
try!(serialize(&mut vec, thing)); serialize(&mut vec, thing)?;
Ok(vec) Ok(vec)
} }
@ -290,13 +290,13 @@ impl<'a> Reader for BinReader<'a> {
} }
/// Read a variable size vector from the underlying Read. Expects a usize /// Read a variable size vector from the underlying Read. Expects a usize
fn read_vec(&mut self) -> Result<Vec<u8>, Error> { fn read_vec(&mut self) -> Result<Vec<u8>, Error> {
let len = try!(self.read_u64()); let len = self.read_u64()?;
self.read_fixed_bytes(len as usize) self.read_fixed_bytes(len as usize)
} }
/// Read limited variable size vector from the underlying Read. Expects a /// Read limited variable size vector from the underlying Read. Expects a
/// usize /// usize
fn read_limited_vec(&mut self, max: usize) -> Result<Vec<u8>, Error> { fn read_limited_vec(&mut self, max: usize) -> Result<Vec<u8>, Error> {
let len = cmp::min(max, try!(self.read_u64()) as usize); let len = cmp::min(max, self.read_u64()? as usize);
self.read_fixed_bytes(len as usize) self.read_fixed_bytes(len as usize)
} }
fn read_fixed_bytes(&mut self, length: usize) -> Result<Vec<u8>, Error> { fn read_fixed_bytes(&mut self, length: usize) -> Result<Vec<u8>, Error> {
@ -312,7 +312,7 @@ impl<'a> Reader for BinReader<'a> {
} }
fn expect_u8(&mut self, val: u8) -> Result<u8, Error> { fn expect_u8(&mut self, val: u8) -> Result<u8, Error> {
let b = try!(self.read_u8()); let b = self.read_u8()?;
if b == val { if b == val {
Ok(b) Ok(b)
} else { } else {
@ -326,7 +326,7 @@ impl<'a> Reader for BinReader<'a> {
impl Readable for Commitment { impl Readable for Commitment {
fn read(reader: &mut Reader) -> Result<Commitment, Error> { fn read(reader: &mut Reader) -> Result<Commitment, Error> {
let a = try!(reader.read_fixed_bytes(PEDERSEN_COMMITMENT_SIZE)); let a = reader.read_fixed_bytes(PEDERSEN_COMMITMENT_SIZE)?;
let mut c = [0; PEDERSEN_COMMITMENT_SIZE]; let mut c = [0; PEDERSEN_COMMITMENT_SIZE];
for i in 0..PEDERSEN_COMMITMENT_SIZE { for i in 0..PEDERSEN_COMMITMENT_SIZE {
c[i] = a[i]; c[i] = a[i];
@ -395,7 +395,7 @@ impl PMMRable for RangeProof {
impl Readable for Signature { impl Readable for Signature {
fn read(reader: &mut Reader) -> Result<Signature, Error> { fn read(reader: &mut Reader) -> Result<Signature, Error> {
let a = try!(reader.read_fixed_bytes(AGG_SIGNATURE_SIZE)); let a = reader.read_fixed_bytes(AGG_SIGNATURE_SIZE)?;
let mut c = [0; AGG_SIGNATURE_SIZE]; let mut c = [0; AGG_SIGNATURE_SIZE];
for i in 0..AGG_SIGNATURE_SIZE { for i in 0..AGG_SIGNATURE_SIZE {
c[i] = a[i]; c[i] = a[i];
@ -423,7 +423,7 @@ impl<'a> Writer for BinWriter<'a> {
fn write_fixed_bytes<T: AsFixedBytes>(&mut self, fixed: &T) -> Result<(), Error> { fn write_fixed_bytes<T: AsFixedBytes>(&mut self, fixed: &T) -> Result<(), Error> {
let bs = fixed.as_ref(); let bs = fixed.as_ref();
try!(self.sink.write_all(bs)); self.sink.write_all(bs)?;
Ok(()) Ok(())
} }
} }
@ -504,30 +504,30 @@ impl<'a, A: Writeable> Writeable for &'a A {
impl<A: Writeable, B: Writeable> Writeable for (A, B) { impl<A: Writeable, B: Writeable> Writeable for (A, B) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
try!(Writeable::write(&self.0, writer)); Writeable::write(&self.0, writer)?;
Writeable::write(&self.1, writer) Writeable::write(&self.1, writer)
} }
} }
impl<A: Readable, B: Readable> Readable for (A, B) { impl<A: Readable, B: Readable> Readable for (A, B) {
fn read(reader: &mut Reader) -> Result<(A, B), Error> { fn read(reader: &mut Reader) -> Result<(A, B), Error> {
Ok((try!(Readable::read(reader)), try!(Readable::read(reader)))) Ok((Readable::read(reader)?, Readable::read(reader)?))
} }
} }
impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) { impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
try!(Writeable::write(&self.0, writer)); Writeable::write(&self.0, writer)?;
try!(Writeable::write(&self.1, writer)); Writeable::write(&self.1, writer)?;
Writeable::write(&self.2, writer) Writeable::write(&self.2, writer)
} }
} }
impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B, C, D) { impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B, C, D) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
try!(Writeable::write(&self.0, writer)); Writeable::write(&self.0, writer)?;
try!(Writeable::write(&self.1, writer)); Writeable::write(&self.1, writer)?;
try!(Writeable::write(&self.2, writer)); Writeable::write(&self.2, writer)?;
Writeable::write(&self.3, writer) Writeable::write(&self.3, writer)
} }
} }
@ -535,9 +535,9 @@ impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B
impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) { impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
fn read(reader: &mut Reader) -> Result<(A, B, C), Error> { fn read(reader: &mut Reader) -> Result<(A, B, C), Error> {
Ok(( Ok((
try!(Readable::read(reader)), Readable::read(reader)?,
try!(Readable::read(reader)), Readable::read(reader)?,
try!(Readable::read(reader)), Readable::read(reader)?,
)) ))
} }
} }
@ -545,10 +545,10 @@ impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
impl<A: Readable, B: Readable, C: Readable, D: Readable> Readable for (A, B, C, D) { impl<A: Readable, B: Readable, C: Readable, D: Readable> Readable for (A, B, C, D) {
fn read(reader: &mut Reader) -> Result<(A, B, C, D), Error> { fn read(reader: &mut Reader) -> Result<(A, B, C, D), Error> {
Ok(( Ok((
try!(Readable::read(reader)), Readable::read(reader)?,
try!(Readable::read(reader)), Readable::read(reader)?,
try!(Readable::read(reader)), Readable::read(reader)?,
try!(Readable::read(reader)), Readable::read(reader)?,
)) ))
} }
} }

14
keychain/src/extkey.rs
View file

@ -12,17 +12,17 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
use std::{error, fmt, num};
use std::cmp::min; use std::cmp::min;
use std::{error, fmt, num};
use serde::{de, ser}; use serde::{de, ser};
use byteorder::{BigEndian, ByteOrder};
use blake2::blake2b::blake2b; use blake2::blake2b::blake2b;
use byteorder::{BigEndian, ByteOrder};
use util;
use util::secp; use util::secp;
use util::secp::Secp256k1; use util::secp::Secp256k1;
use util::secp::key::{PublicKey, SecretKey}; use util::secp::key::{PublicKey, SecretKey};
use util;
// Size of an identifier in bytes // Size of an identifier in bytes
pub const IDENTIFIER_SIZE: usize = 10; pub const IDENTIFIER_SIZE: usize = 10;
@ -162,8 +162,8 @@ impl AsRef<[u8]> for Identifier {
impl ::std::fmt::Debug for Identifier { impl ::std::fmt::Debug for Identifier {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
try!(write!(f, "{}(", stringify!(Identifier))); write!(f, "{}(", stringify!(Identifier))?;
try!(write!(f, "{}", self.to_hex())); write!(f, "{}", self.to_hex())?;
write!(f, ")") write!(f, ")")
} }
} }
@ -269,10 +269,10 @@ impl ExtendedKey {
mod test { mod test {
use serde_json; use serde_json;
use util::secp::Secp256k1;
use util::secp::key::SecretKey;
use super::{ExtendedKey, Identifier}; use super::{ExtendedKey, Identifier};
use util; use util;
use util::secp::Secp256k1;
use util::secp::key::SecretKey;
fn from_hex(hex_str: &str) -> Vec<u8> { fn from_hex(hex_str: &str) -> Vec<u8> {
util::from_hex(hex_str.to_string()).unwrap() util::from_hex(hex_str.to_string()).unwrap()

54
p2p/src/msg.rs
View file

@ -21,9 +21,9 @@ use std::thread;
use std::time; use std::time;
use core::consensus::{MAX_MSG_LEN, MAX_TX_INPUTS, MAX_TX_KERNELS, MAX_TX_OUTPUTS}; use core::consensus::{MAX_MSG_LEN, MAX_TX_INPUTS, MAX_TX_KERNELS, MAX_TX_OUTPUTS};
use core::core::BlockHeader;
use core::core::hash::Hash; use core::core::hash::Hash;
use core::core::target::Difficulty; use core::core::target::Difficulty;
use core::core::BlockHeader;
use core::ser::{self, Readable, Reader, Writeable, Writer}; use core::ser::{self, Readable, Reader, Writeable, Writer};
use types::*; use types::*;
@ -291,8 +291,8 @@ impl Writeable for MsgHeader {
impl Readable for MsgHeader { impl Readable for MsgHeader {
fn read(reader: &mut Reader) -> Result<MsgHeader, ser::Error> { fn read(reader: &mut Reader) -> Result<MsgHeader, ser::Error> {
try!(reader.expect_u8(MAGIC[0])); reader.expect_u8(MAGIC[0])?;
try!(reader.expect_u8(MAGIC[1])); reader.expect_u8(MAGIC[1])?;
let (t, len) = ser_multiread!(reader, read_u8, read_u64); let (t, len) = ser_multiread!(reader, read_u8, read_u64);
match Type::from_u8(t) { match Type::from_u8(t) {
Some(ty) => Ok(MsgHeader { Some(ty) => Ok(MsgHeader {
@ -347,13 +347,13 @@ impl Writeable for Hand {
impl Readable for Hand { impl Readable for Hand {
fn read(reader: &mut Reader) -> Result<Hand, ser::Error> { fn read(reader: &mut Reader) -> Result<Hand, ser::Error> {
let (version, capab, nonce) = ser_multiread!(reader, read_u32, read_u32, read_u64); let (version, capab, nonce) = ser_multiread!(reader, read_u32, read_u32, read_u64);
let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,)); let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
let total_diff = try!(Difficulty::read(reader)); let total_diff = Difficulty::read(reader)?;
let sender_addr = try!(SockAddr::read(reader)); let sender_addr = SockAddr::read(reader)?;
let receiver_addr = try!(SockAddr::read(reader)); let receiver_addr = SockAddr::read(reader)?;
let ua = try!(reader.read_vec()); let ua = reader.read_vec()?;
let user_agent = try!(String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)); let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
let genesis = try!(Hash::read(reader)); let genesis = Hash::read(reader)?;
Ok(Hand { Ok(Hand {
version: version, version: version,
capabilities: capabilities, capabilities: capabilities,
@ -400,11 +400,11 @@ impl Writeable for Shake {
impl Readable for Shake { impl Readable for Shake {
fn read(reader: &mut Reader) -> Result<Shake, ser::Error> { fn read(reader: &mut Reader) -> Result<Shake, ser::Error> {
let (version, capab) = ser_multiread!(reader, read_u32, read_u32); let (version, capab) = ser_multiread!(reader, read_u32, read_u32);
let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,)); let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
let total_diff = try!(Difficulty::read(reader)); let total_diff = Difficulty::read(reader)?;
let ua = try!(reader.read_vec()); let ua = reader.read_vec()?;
let user_agent = try!(String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)); let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
let genesis = try!(Hash::read(reader)); let genesis = Hash::read(reader)?;
Ok(Shake { Ok(Shake {
version: version, version: version,
capabilities: capabilities, capabilities: capabilities,
@ -429,8 +429,8 @@ impl Writeable for GetPeerAddrs {
impl Readable for GetPeerAddrs { impl Readable for GetPeerAddrs {
fn read(reader: &mut Reader) -> Result<GetPeerAddrs, ser::Error> { fn read(reader: &mut Reader) -> Result<GetPeerAddrs, ser::Error> {
let capab = try!(reader.read_u32()); let capab = reader.read_u32()?;
let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,)); let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
Ok(GetPeerAddrs { Ok(GetPeerAddrs {
capabilities: capabilities, capabilities: capabilities,
}) })
@ -446,7 +446,7 @@ pub struct PeerAddrs {
impl Writeable for PeerAddrs { impl Writeable for PeerAddrs {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
try!(writer.write_u32(self.peers.len() as u32)); writer.write_u32(self.peers.len() as u32)?;
for p in &self.peers { for p in &self.peers {
p.write(writer).unwrap(); p.write(writer).unwrap();
} }
@ -456,7 +456,7 @@ impl Writeable for PeerAddrs {
impl Readable for PeerAddrs { impl Readable for PeerAddrs {
fn read(reader: &mut Reader) -> Result<PeerAddrs, ser::Error> { fn read(reader: &mut Reader) -> Result<PeerAddrs, ser::Error> {
let peer_count = try!(reader.read_u32()); let peer_count = reader.read_u32()?;
if peer_count > MAX_PEER_ADDRS { if peer_count > MAX_PEER_ADDRS {
return Err(ser::Error::TooLargeReadErr); return Err(ser::Error::TooLargeReadErr);
} else if peer_count == 0 { } else if peer_count == 0 {
@ -490,7 +490,7 @@ impl Writeable for PeerError {
impl Readable for PeerError { impl Readable for PeerError {
fn read(reader: &mut Reader) -> Result<PeerError, ser::Error> { fn read(reader: &mut Reader) -> Result<PeerError, ser::Error> {
let (code, msg) = ser_multiread!(reader, read_u32, read_vec); let (code, msg) = ser_multiread!(reader, read_u32, read_vec);
let message = try!(String::from_utf8(msg).map_err(|_| ser::Error::CorruptedData,)); let message = String::from_utf8(msg).map_err(|_| ser::Error::CorruptedData)?;
Ok(PeerError { Ok(PeerError {
code: code, code: code,
message: message, message: message,
@ -516,11 +516,11 @@ impl Writeable for SockAddr {
); );
} }
SocketAddr::V6(sav6) => { SocketAddr::V6(sav6) => {
try!(writer.write_u8(1)); writer.write_u8(1)?;
for seg in &sav6.ip().segments() { for seg in &sav6.ip().segments() {
try!(writer.write_u16(*seg)); writer.write_u16(*seg)?;
} }
try!(writer.write_u16(sav6.port())); writer.write_u16(sav6.port())?;
} }
} }
Ok(()) Ok(())
@ -529,17 +529,17 @@ impl Writeable for SockAddr {
impl Readable for SockAddr { impl Readable for SockAddr {
fn read(reader: &mut Reader) -> Result<SockAddr, ser::Error> { fn read(reader: &mut Reader) -> Result<SockAddr, ser::Error> {
let v4_or_v6 = try!(reader.read_u8()); let v4_or_v6 = reader.read_u8()?;
if v4_or_v6 == 0 { if v4_or_v6 == 0 {
let ip = try!(reader.read_fixed_bytes(4)); let ip = reader.read_fixed_bytes(4)?;
let port = try!(reader.read_u16()); let port = reader.read_u16()?;
Ok(SockAddr(SocketAddr::V4(SocketAddrV4::new( Ok(SockAddr(SocketAddr::V4(SocketAddrV4::new(
Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3]), Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3]),
port, port,
)))) ))))
} else { } else {
let ip = try_map_vec!([0..8], |_| reader.read_u16()); let ip = try_map_vec!([0..8], |_| reader.read_u16());
let port = try!(reader.read_u16()); let port = reader.read_u16()?;
Ok(SockAddr(SocketAddr::V6(SocketAddrV6::new( Ok(SockAddr(SocketAddr::V6(SocketAddrV6::new(
Ipv6Addr::new(ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]), Ipv6Addr::new(ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]),
port, port,

6
store/src/lib.rs
View file

@ -91,7 +91,7 @@ impl Store {
opts.set_compaction_style(DBCompactionStyle::Universal); opts.set_compaction_style(DBCompactionStyle::Universal);
opts.set_max_open_files(256); opts.set_max_open_files(256);
opts.set_use_fsync(false); opts.set_use_fsync(false);
let db = try!(DB::open(&opts, &path)); let db = DB::open(&opts, &path)?;
Ok(Store { Ok(Store {
rdb: RwLock::new(db), rdb: RwLock::new(db),
}) })
@ -135,11 +135,11 @@ impl Store {
key: &[u8], key: &[u8],
len: usize, len: usize,
) -> Result<Option<T>, Error> { ) -> Result<Option<T>, Error> {
let data = try!(self.get(key)); let data = self.get(key)?;
match data { match data {
Some(val) => { Some(val) => {
let mut lval = if len > 0 { &val[..len] } else { &val[..] }; let mut lval = if len > 0 { &val[..len] } else { &val[..] };
let r = try!(ser::deserialize(&mut lval).map_err(Error::SerErr)); let r = ser::deserialize(&mut lval).map_err(Error::SerErr)?;
Ok(Some(r)) Ok(Some(r))
} }
None => Ok(None), None => Ok(None),