Update try!() to new ? syntax for Rust 2018 edition
Not automatically updated, see https://users.rust-lang.org/t/why-does-cargo-fix-replace-try-with-r-try-instead-of/21972/3 There are other tools to replace it, btu this is what I used: find src -name '*.rs' -exec perl -MRegexp::Common -0777 -pe'$bp=$RE{balanced}{-parens=>"()"}; s/try\!($bp)/substr($1, 1, length($1) - 2) . "?"/ges' -i {} \;
This commit is contained in:
parent
d31a58b3eb
commit
099e10195b
|
@ -147,10 +147,10 @@ impl TextComponent {
|
|||
|
||||
impl fmt::Display for TextComponent {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
try!(write!(f, "{}", self.text));
|
||||
write!(f, "{}", self.text)?;
|
||||
if let Some(ref extra) = self.modifier.extra {
|
||||
for c in extra {
|
||||
try!(write!(f, "{}", c));
|
||||
write!(f, "{}", c)?;
|
||||
}
|
||||
}
|
||||
Result::Ok(())
|
||||
|
|
|
@ -39,26 +39,26 @@ impl Default for Stack {
|
|||
|
||||
impl Serializable for Option<Stack> {
|
||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<Stack>, protocol::Error> {
|
||||
let id = try!(buf.read_i16::<BigEndian>());
|
||||
let id = buf.read_i16::<BigEndian>()?;
|
||||
if id == -1 {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(Stack {
|
||||
id: id as isize,
|
||||
count: try!(buf.read_u8()) as isize,
|
||||
damage: try!(buf.read_i16::<BigEndian>()) as isize,
|
||||
tag: try!(Serializable::read_from(buf)),
|
||||
count: buf.read_u8()? as isize,
|
||||
damage: buf.read_i16::<BigEndian>()? as isize,
|
||||
tag: Serializable::read_from(buf)?,
|
||||
}))
|
||||
}
|
||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||
match *self {
|
||||
Some(ref val) => {
|
||||
try!(buf.write_i16::<BigEndian>(val.id as i16));
|
||||
try!(buf.write_u8(val.count as u8));
|
||||
try!(buf.write_i16::<BigEndian>(val.damage as i16));
|
||||
try!(val.tag.write_to(buf));
|
||||
buf.write_i16::<BigEndian>(val.id as i16)?;
|
||||
buf.write_u8(val.count as u8)?;
|
||||
buf.write_i16::<BigEndian>(val.damage as i16)?;
|
||||
val.tag.write_to(buf)?;
|
||||
}
|
||||
None => try!(buf.write_i16::<BigEndian>(-1)),
|
||||
None => buf.write_i16::<BigEndian>(-1)?,
|
||||
}
|
||||
Result::Ok(())
|
||||
}
|
||||
|
|
|
@ -175,45 +175,45 @@ impl Tag {
|
|||
fn read_type<R: io::Read>(id: u8, buf: &mut R) -> Result<Tag, protocol::Error> {
|
||||
match id {
|
||||
0 => unreachable!(),
|
||||
1 => Ok(Tag::Byte(try!(buf.read_i8()))),
|
||||
2 => Ok(Tag::Short(try!(buf.read_i16::<BigEndian>()))),
|
||||
3 => Ok(Tag::Int(try!(buf.read_i32::<BigEndian>()))),
|
||||
4 => Ok(Tag::Long(try!(buf.read_i64::<BigEndian>()))),
|
||||
5 => Ok(Tag::Float(try!(buf.read_f32::<BigEndian>()))),
|
||||
6 => Ok(Tag::Double(try!(buf.read_f64::<BigEndian>()))),
|
||||
1 => Ok(Tag::Byte(buf.read_i8()?)),
|
||||
2 => Ok(Tag::Short(buf.read_i16::<BigEndian>()?)),
|
||||
3 => Ok(Tag::Int(buf.read_i32::<BigEndian>()?)),
|
||||
4 => Ok(Tag::Long(buf.read_i64::<BigEndian>()?)),
|
||||
5 => Ok(Tag::Float(buf.read_f32::<BigEndian>()?)),
|
||||
6 => Ok(Tag::Double(buf.read_f64::<BigEndian>()?)),
|
||||
7 => Ok(Tag::ByteArray({
|
||||
let len: i32 = try!(Serializable::read_from(buf));
|
||||
let len: i32 = Serializable::read_from(buf)?;
|
||||
let mut data = Vec::with_capacity(len as usize);
|
||||
try!(buf.take(len as u64).read_to_end(&mut data));
|
||||
buf.take(len as u64).read_to_end(&mut data)?;
|
||||
data
|
||||
})),
|
||||
8 => Ok(Tag::String(try!(read_string(buf)))),
|
||||
8 => Ok(Tag::String(read_string(buf)?)),
|
||||
9 => {
|
||||
let mut l = Vec::new();
|
||||
let ty = try!(buf.read_u8());
|
||||
let len: i32 = try!(Serializable::read_from(buf));
|
||||
let ty = buf.read_u8()?;
|
||||
let len: i32 = Serializable::read_from(buf)?;
|
||||
for _ in 0..len {
|
||||
l.push(try!(Tag::read_type(ty, buf)));
|
||||
l.push(Tag::read_type(ty, buf)?);
|
||||
}
|
||||
Ok(Tag::List(l))
|
||||
}
|
||||
10 => {
|
||||
let mut c = Tag::new_compound();
|
||||
loop {
|
||||
let ty = try!(buf.read_u8());
|
||||
let ty = buf.read_u8()?;
|
||||
if ty == 0 {
|
||||
break;
|
||||
}
|
||||
let name: String = try!(read_string(buf));
|
||||
c.put(&name[..], try!(Tag::read_type(ty, buf)));
|
||||
let name: String = read_string(buf)?;
|
||||
c.put(&name[..], Tag::read_type(ty, buf)?);
|
||||
}
|
||||
Ok(c)
|
||||
}
|
||||
11 => Ok(Tag::IntArray({
|
||||
let len: i32 = try!(Serializable::read_from(buf));
|
||||
let len: i32 = Serializable::read_from(buf)?;
|
||||
let mut data = Vec::with_capacity(len as usize);
|
||||
for _ in 0..len {
|
||||
data.push(try!(buf.read_i32::<BigEndian>()));
|
||||
data.push(buf.read_i32::<BigEndian>()?);
|
||||
}
|
||||
data
|
||||
})),
|
||||
|
@ -230,41 +230,41 @@ impl Serializable for Tag {
|
|||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||
match *self {
|
||||
Tag::End => {}
|
||||
Tag::Byte(val) => try!(buf.write_i8(val)),
|
||||
Tag::Short(val) => try!(buf.write_i16::<BigEndian>(val)),
|
||||
Tag::Int(val) => try!(buf.write_i32::<BigEndian>(val)),
|
||||
Tag::Long(val) => try!(buf.write_i64::<BigEndian>(val)),
|
||||
Tag::Float(val) => try!(buf.write_f32::<BigEndian>(val)),
|
||||
Tag::Double(val) => try!(buf.write_f64::<BigEndian>(val)),
|
||||
Tag::Byte(val) => buf.write_i8(val)?,
|
||||
Tag::Short(val) => buf.write_i16::<BigEndian>(val)?,
|
||||
Tag::Int(val) => buf.write_i32::<BigEndian>(val)?,
|
||||
Tag::Long(val) => buf.write_i64::<BigEndian>(val)?,
|
||||
Tag::Float(val) => buf.write_f32::<BigEndian>(val)?,
|
||||
Tag::Double(val) => buf.write_f64::<BigEndian>(val)?,
|
||||
Tag::ByteArray(ref val) => {
|
||||
try!((val.len() as i32).write_to(buf));
|
||||
try!(buf.write_all(val));
|
||||
(val.len() as i32).write_to(buf)?;
|
||||
buf.write_all(val)?;
|
||||
}
|
||||
Tag::String(ref val) => try!(write_string(buf, val)),
|
||||
Tag::String(ref val) => write_string(buf, val)?,
|
||||
Tag::List(ref val) => {
|
||||
if val.is_empty() {
|
||||
try!(buf.write_u8(0));
|
||||
try!(buf.write_i32::<BigEndian>(0));
|
||||
buf.write_u8(0)?;
|
||||
buf.write_i32::<BigEndian>(0)?;
|
||||
} else {
|
||||
try!(buf.write_u8(val[0].internal_id()));
|
||||
try!(buf.write_i32::<BigEndian>(val.len() as i32));
|
||||
buf.write_u8(val[0].internal_id())?;
|
||||
buf.write_i32::<BigEndian>(val.len() as i32)?;
|
||||
for e in val {
|
||||
try!(e.write_to(buf));
|
||||
e.write_to(buf)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Tag::Compound(ref val) => {
|
||||
for (k, v) in val {
|
||||
try!(v.internal_id().write_to(buf));
|
||||
try!(write_string(buf, k));
|
||||
try!(v.write_to(buf));
|
||||
v.internal_id().write_to(buf)?;
|
||||
write_string(buf, k)?;
|
||||
v.write_to(buf)?;
|
||||
}
|
||||
try!(buf.write_u8(0));
|
||||
buf.write_u8(0)?;
|
||||
}
|
||||
Tag::IntArray(ref val) => {
|
||||
try!((val.len() as i32).write_to(buf));
|
||||
(val.len() as i32).write_to(buf)?;
|
||||
for v in val {
|
||||
try!(v.write_to(buf));
|
||||
v.write_to(buf)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -274,13 +274,13 @@ impl Serializable for Tag {
|
|||
|
||||
pub fn write_string<W: io::Write>(buf: &mut W, s: &str) -> Result<(), protocol::Error> {
|
||||
let data = s.as_bytes();
|
||||
try!((data.len() as i16).write_to(buf));
|
||||
(data.len() as i16).write_to(buf)?;
|
||||
buf.write_all(data).map_err(|v| v.into())
|
||||
}
|
||||
|
||||
pub fn read_string<R: io::Read>(buf: &mut R) -> Result<String, protocol::Error> {
|
||||
let len: i16 = try!(buf.read_i16::<BigEndian>());
|
||||
let len: i16 = buf.read_i16::<BigEndian>()?;
|
||||
let mut ret = String::new();
|
||||
try!(buf.take(len as u64).read_to_string(&mut ret));
|
||||
buf.take(len as u64).read_to_string(&mut ret)?;
|
||||
Result::Ok(ret)
|
||||
}
|
||||
|
|
|
@ -64,40 +64,40 @@ impl Serializable for Metadata {
|
|||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, protocol::Error> {
|
||||
let mut m = Metadata::new();
|
||||
loop {
|
||||
let index = try!(u8::read_from(buf)) as i32;
|
||||
let index = u8::read_from(buf)? as i32;
|
||||
if index == 0xFF {
|
||||
break;
|
||||
}
|
||||
let ty = try!(u8::read_from(buf));
|
||||
let ty = u8::read_from(buf)?;
|
||||
match ty {
|
||||
0 => m.put_raw(index, try!(i8::read_from(buf))),
|
||||
1 => m.put_raw(index, try!(protocol::VarInt::read_from(buf)).0),
|
||||
2 => m.put_raw(index, try!(f32::read_from(buf))),
|
||||
3 => m.put_raw(index, try!(String::read_from(buf))),
|
||||
4 => m.put_raw(index, try!(format::Component::read_from(buf))),
|
||||
5 => m.put_raw(index, try!(Option::<item::Stack>::read_from(buf))),
|
||||
6 => m.put_raw(index, try!(bool::read_from(buf))),
|
||||
0 => m.put_raw(index, i8::read_from(buf)?),
|
||||
1 => m.put_raw(index, protocol::VarInt::read_from(buf)?.0),
|
||||
2 => m.put_raw(index, f32::read_from(buf)?),
|
||||
3 => m.put_raw(index, String::read_from(buf)?),
|
||||
4 => m.put_raw(index, format::Component::read_from(buf)?),
|
||||
5 => m.put_raw(index, Option::<item::Stack>::read_from(buf)?),
|
||||
6 => m.put_raw(index, bool::read_from(buf)?),
|
||||
7 => m.put_raw(index,
|
||||
[try!(f32::read_from(buf)),
|
||||
try!(f32::read_from(buf)),
|
||||
try!(f32::read_from(buf))]),
|
||||
8 => m.put_raw(index, try!(Position::read_from(buf))),
|
||||
[f32::read_from(buf)?,
|
||||
f32::read_from(buf)?,
|
||||
f32::read_from(buf)?]),
|
||||
8 => m.put_raw(index, Position::read_from(buf)?),
|
||||
9 => {
|
||||
if try!(bool::read_from(buf)) {
|
||||
m.put_raw(index, try!(Option::<Position>::read_from(buf)));
|
||||
if bool::read_from(buf)? {
|
||||
m.put_raw(index, Option::<Position>::read_from(buf)?);
|
||||
} else {
|
||||
m.put_raw::<Option<Position>>(index, None);
|
||||
}
|
||||
}
|
||||
10 => m.put_raw(index, try!(protocol::VarInt::read_from(buf))),
|
||||
10 => m.put_raw(index, protocol::VarInt::read_from(buf)?),
|
||||
11 => {
|
||||
if try!(bool::read_from(buf)) {
|
||||
m.put_raw(index, try!(Option::<protocol::UUID>::read_from(buf)));
|
||||
if bool::read_from(buf)? {
|
||||
m.put_raw(index, Option::<protocol::UUID>::read_from(buf)?);
|
||||
} else {
|
||||
m.put_raw::<Option<protocol::UUID>>(index, None);
|
||||
}
|
||||
}
|
||||
12 => m.put_raw(index, try!(protocol::VarInt::read_from(buf)).0 as u16),
|
||||
12 => m.put_raw(index, protocol::VarInt::read_from(buf)?.0 as u16),
|
||||
_ => return Err(protocol::Error::Err("unknown metadata type".to_owned())),
|
||||
}
|
||||
}
|
||||
|
@ -106,76 +106,76 @@ impl Serializable for Metadata {
|
|||
|
||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||
for (k, v) in &self.map {
|
||||
try!((*k as u8).write_to(buf));
|
||||
(*k as u8).write_to(buf)?;
|
||||
match *v {
|
||||
Value::Byte(ref val) => {
|
||||
try!(u8::write_to(&0, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&0, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::Int(ref val) => {
|
||||
try!(u8::write_to(&1, buf));
|
||||
try!(protocol::VarInt(*val).write_to(buf));
|
||||
u8::write_to(&1, buf)?;
|
||||
protocol::VarInt(*val).write_to(buf)?;
|
||||
}
|
||||
Value::Float(ref val) => {
|
||||
try!(u8::write_to(&2, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&2, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::String(ref val) => {
|
||||
try!(u8::write_to(&3, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&3, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::FormatComponent(ref val) => {
|
||||
try!(u8::write_to(&4, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&4, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::OptionalItemStack(ref val) => {
|
||||
try!(u8::write_to(&5, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&5, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::Bool(ref val) => {
|
||||
try!(u8::write_to(&6, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&6, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::Vector(ref val) => {
|
||||
try!(u8::write_to(&7, buf));
|
||||
try!(val[0].write_to(buf));
|
||||
try!(val[1].write_to(buf));
|
||||
try!(val[2].write_to(buf));
|
||||
u8::write_to(&7, buf)?;
|
||||
val[0].write_to(buf)?;
|
||||
val[1].write_to(buf)?;
|
||||
val[2].write_to(buf)?;
|
||||
}
|
||||
Value::Position(ref val) => {
|
||||
try!(u8::write_to(&8, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&8, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::OptionalPosition(ref val) => {
|
||||
try!(u8::write_to(&9, buf));
|
||||
try!(val.is_some().write_to(buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&9, buf)?;
|
||||
val.is_some().write_to(buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::Direction(ref val) => {
|
||||
try!(u8::write_to(&10, buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&10, buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::OptionalUUID(ref val) => {
|
||||
try!(u8::write_to(&11, buf));
|
||||
try!(val.is_some().write_to(buf));
|
||||
try!(val.write_to(buf));
|
||||
u8::write_to(&11, buf)?;
|
||||
val.is_some().write_to(buf)?;
|
||||
val.write_to(buf)?;
|
||||
}
|
||||
Value::Block(ref val) => {
|
||||
try!(u8::write_to(&11, buf));
|
||||
try!(protocol::VarInt(*val as i32).write_to(buf));
|
||||
u8::write_to(&11, buf)?;
|
||||
protocol::VarInt(*val as i32).write_to(buf)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
try!(u8::write_to(&0xFF, buf));
|
||||
u8::write_to(&0xFF, buf)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Metadata {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
try!(write!(f, "Metadata[ "));
|
||||
write!(f, "Metadata[ ")?;
|
||||
for (k, v) in &self.map {
|
||||
try!(write!(f, "{:?}={:?}, ", k, v));
|
||||
write!(f, "{:?}={:?}, ", k, v)?;
|
||||
}
|
||||
write!(f, "]")
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue