berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix compile warnings caused by deprecated macros.

This commit is contained in:
Leonard Kramer 2020-01-04 18:12:20 +00:00 committed by Josh Matthews
parent e2d8742743
commit c48a064bad
3 changed files with 49 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/de/mod.rs
View File

@ -48,7 +48,7 @@ impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> {
} }
fn read_vec(&mut self) -> Result<Vec<u8>> { fn read_vec(&mut self) -> Result<Vec<u8>> {
let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); let len: usize = serde::Deserialize::deserialize(&mut *self)?;
self.read_bytes(len as u64)?; self.read_bytes(len as u64)?;
self.reader.get_byte_buffer(len) self.reader.get_byte_buffer(len)
} }
@ -65,8 +65,8 @@ macro_rules! impl_nums {
fn $dser_method<V>(self, visitor: V) -> Result<V::Value> fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>, where V: serde::de::Visitor<'de>,
{ {
try!(self.read_type::<$ty>()); self.read_type::<$ty>()?;
let value = try!(self.reader.$reader_method::<O::Endian>()); let value = self.reader.$reader_method::<O::Endian>()?;
visitor.$visitor_method(value) visitor.$visitor_method(value)
} }
} }
@ -91,7 +91,7 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
let value: u8 = try!(serde::Deserialize::deserialize(self)); let value: u8 = serde::Deserialize::deserialize(self)?;
match value { match value {
1 => visitor.visit_bool(true), 1 => visitor.visit_bool(true),
0 => visitor.visit_bool(false), 0 => visitor.visit_bool(false),
@ -118,8 +118,8 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
try!(self.read_type::<u8>()); self.read_type::<u8>()?;
visitor.visit_u8(try!(self.reader.read_u8())) visitor.visit_u8(self.reader.read_u8()?)
} }
#[inline] #[inline]
@ -127,8 +127,8 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
try!(self.read_type::<i8>()); self.read_type::<i8>()?;
visitor.visit_i8(try!(self.reader.read_i8())) visitor.visit_i8(self.reader.read_i8()?)
} }
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
@ -149,7 +149,7 @@ where
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
// Look at the first byte to see how many bytes must be read // Look at the first byte to see how many bytes must be read
let _ = try!(self.reader.read_exact(&mut buf[..1])); let _ = self.reader.read_exact(&mut buf[..1])?;
let width = utf8_char_width(buf[0]); let width = utf8_char_width(buf[0]);
if width == 1 { if width == 1 {
return visitor.visit_char(buf[0] as char); return visitor.visit_char(buf[0] as char);
@ -162,12 +162,10 @@ where
return Err(error()); return Err(error());
} }
let res = try!( let res = str::from_utf8(&buf[..width])
str::from_utf8(&buf[..width])
.ok() .ok()
.and_then(|s| s.chars().next()) .and_then(|s| s.chars().next())
.ok_or(error()) .ok_or(error())?;
);
visitor.visit_char(res) visitor.visit_char(res)
} }
@ -175,8 +173,8 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); let len: usize = serde::Deserialize::deserialize(&mut *self)?;
try!(self.read_bytes(len as u64)); self.read_bytes(len as u64)?;
self.reader.forward_read_str(len, visitor) self.reader.forward_read_str(len, visitor)
} }
@ -184,15 +182,15 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
visitor.visit_string(try!(self.read_string())) visitor.visit_string(self.read_string()?)
} }
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); let len: usize = serde::Deserialize::deserialize(&mut *self)?;
try!(self.read_bytes(len as u64)); self.read_bytes(len as u64)?;
self.reader.forward_read_bytes(len, visitor) self.reader.forward_read_bytes(len, visitor)
} }
@ -200,7 +198,7 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
visitor.visit_byte_buf(try!(self.read_vec())) visitor.visit_byte_buf(self.read_vec()?)
} }
fn deserialize_enum<V>( fn deserialize_enum<V>(
@ -224,9 +222,9 @@ where
where where
V: serde::de::DeserializeSeed<'de>, V: serde::de::DeserializeSeed<'de>,
{ {
let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self)); let idx: u32 = serde::de::Deserialize::deserialize(&mut *self)?;
let val: Result<_> = seed.deserialize(idx.into_deserializer()); let val: Result<_> = seed.deserialize(idx.into_deserializer());
Ok((try!(val), self)) Ok((val?, self))
} }
} }
@ -253,10 +251,10 @@ where
{ {
if self.len > 0 { if self.len > 0 {
self.len -= 1; self.len -= 1;
let value = try!(serde::de::DeserializeSeed::deserialize( let value = serde::de::DeserializeSeed::deserialize(
seed, seed,
&mut *self.deserializer, &mut *self.deserializer,
)); )?;
Ok(Some(value)) Ok(Some(value))
} else { } else {
Ok(None) Ok(None)
@ -278,7 +276,7 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self)); let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?;
match value { match value {
0 => visitor.visit_none(), 0 => visitor.visit_none(),
1 => visitor.visit_some(&mut *self), 1 => visitor.visit_some(&mut *self),
@ -290,7 +288,7 @@ where
where where
V: serde::de::Visitor<'de>, V: serde::de::Visitor<'de>,
{ {
let len = try!(serde::Deserialize::deserialize(&mut *self)); let len = serde::Deserialize::deserialize(&mut *self)?;
self.deserialize_tuple(len, visitor) self.deserialize_tuple(len, visitor)
} }
@ -315,10 +313,10 @@ where
{ {
if self.len > 0 { if self.len > 0 {
self.len -= 1; self.len -= 1;
let key = try!(serde::de::DeserializeSeed::deserialize( let key = serde::de::DeserializeSeed::deserialize(
seed, seed,
&mut *self.deserializer, &mut *self.deserializer,
)); )?;
Ok(Some(key)) Ok(Some(key))
} else { } else {
Ok(None) Ok(None)
@ -329,10 +327,10 @@ where
where where
V: serde::de::DeserializeSeed<'de>, V: serde::de::DeserializeSeed<'de>,
{ {
let value = try!(serde::de::DeserializeSeed::deserialize( let value = serde::de::DeserializeSeed::deserialize(
seed, seed,
&mut *self.deserializer, &mut *self.deserializer,
)); )?;
Ok(value) Ok(value)
} }
@ -341,7 +339,7 @@ where
} }
} }
let len = try!(serde::Deserialize::deserialize(&mut *self)); let len = serde::Deserialize::deserialize(&mut *self)?;
visitor.visit_map(Access { visitor.visit_map(Access {
deserializer: self, deserializer: self,

2
src/error.rs
View File

@ -58,7 +58,7 @@ impl StdError for ErrorKind {
} }
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
match *self { match *self {
ErrorKind::Io(ref err) => Some(err), ErrorKind::Io(ref err) => Some(err),
ErrorKind::InvalidUtf8Encoding(_) => None, ErrorKind::InvalidUtf8Encoding(_) => None,

40
src/ser/mod.rs
View File

@ -107,7 +107,7 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
} }
fn serialize_str(self, v: &str) -> Result<()> { fn serialize_str(self, v: &str) -> Result<()> {
try!(self.serialize_u64(v.len() as u64)); self.serialize_u64(v.len() as u64)?;
self.writer.write_all(v.as_bytes()).map_err(Into::into) self.writer.write_all(v.as_bytes()).map_err(Into::into)
} }
@ -118,7 +118,7 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
} }
fn serialize_bytes(self, v: &[u8]) -> Result<()> { fn serialize_bytes(self, v: &[u8]) -> Result<()> {
try!(self.serialize_u64(v.len() as u64)); self.serialize_u64(v.len() as u64)?;
self.writer.write_all(v).map_err(Into::into) self.writer.write_all(v).map_err(Into::into)
} }
@ -130,13 +130,13 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
where where
T: serde::Serialize, T: serde::Serialize,
{ {
try!(self.writer.write_u8(1)); self.writer.write_u8(1)?;
v.serialize(self) v.serialize(self)
} }
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> { fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
try!(self.serialize_u64(len as u64)); self.serialize_u64(len as u64)?;
Ok(Compound { ser: self }) Ok(Compound { ser: self })
} }
@ -159,13 +159,13 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
_variant: &'static str, _variant: &'static str,
_len: usize, _len: usize,
) -> Result<Self::SerializeTupleVariant> { ) -> Result<Self::SerializeTupleVariant> {
try!(self.serialize_u32(variant_index)); self.serialize_u32(variant_index)?;
Ok(Compound { ser: self }) Ok(Compound { ser: self })
} }
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> { fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
try!(self.serialize_u64(len as u64)); self.serialize_u64(len as u64)?;
Ok(Compound { ser: self }) Ok(Compound { ser: self })
} }
@ -180,7 +180,7 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
_variant: &'static str, _variant: &'static str,
_len: usize, _len: usize,
) -> Result<Self::SerializeStructVariant> { ) -> Result<Self::SerializeStructVariant> {
try!(self.serialize_u32(variant_index)); self.serialize_u32(variant_index)?;
Ok(Compound { ser: self }) Ok(Compound { ser: self })
} }
@ -201,7 +201,7 @@ impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
where where
T: serde::ser::Serialize, T: serde::ser::Serialize,
{ {
try!(self.serialize_u32(variant_index)); self.serialize_u32(variant_index)?;
value.serialize(self) value.serialize(self)
} }
@ -312,7 +312,7 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
} }
fn serialize_str(self, v: &str) -> Result<()> { fn serialize_str(self, v: &str) -> Result<()> {
try!(self.add_value(0 as u64)); self.add_value(0 as u64)?;
self.add_raw(v.len() as u64) self.add_raw(v.len() as u64)
} }
@ -321,7 +321,7 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
} }
fn serialize_bytes(self, v: &[u8]) -> Result<()> { fn serialize_bytes(self, v: &[u8]) -> Result<()> {
try!(self.add_value(0 as u64)); self.add_value(0 as u64)?;
self.add_raw(v.len() as u64) self.add_raw(v.len() as u64)
} }
@ -333,14 +333,14 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
where where
T: serde::Serialize, T: serde::Serialize,
{ {
try!(self.add_value(1 as u8)); self.add_value(1 as u8)?;
v.serialize(self) v.serialize(self)
} }
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> { fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
try!(self.serialize_u64(len as u64)); self.serialize_u64(len as u64)?;
Ok(SizeCompound { ser: self }) Ok(SizeCompound { ser: self })
} }
@ -363,14 +363,14 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
_variant: &'static str, _variant: &'static str,
_len: usize, _len: usize,
) -> Result<Self::SerializeTupleVariant> { ) -> Result<Self::SerializeTupleVariant> {
try!(self.add_value(variant_index)); self.add_value(variant_index)?;
Ok(SizeCompound { ser: self }) Ok(SizeCompound { ser: self })
} }
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> { fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
try!(self.serialize_u64(len as u64)); self.serialize_u64(len as u64)?;
Ok(SizeCompound { ser: self }) Ok(SizeCompound { ser: self })
} }
@ -385,7 +385,7 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
_variant: &'static str, _variant: &'static str,
_len: usize, _len: usize,
) -> Result<Self::SerializeStructVariant> { ) -> Result<Self::SerializeStructVariant> {
try!(self.add_value(variant_index)); self.add_value(variant_index)?;
Ok(SizeCompound { ser: self }) Ok(SizeCompound { ser: self })
} }
@ -413,7 +413,7 @@ impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
_variant: &'static str, _variant: &'static str,
value: &V, value: &V,
) -> Result<()> { ) -> Result<()> {
try!(self.add_value(variant_index)); self.add_value(variant_index)?;
value.serialize(self) value.serialize(self)
} }