diff --git a/protocol/src/protocol/mod.rs b/protocol/src/protocol/mod.rs index 53bc638..e565712 100644 --- a/protocol/src/protocol/mod.rs +++ b/protocol/src/protocol/mod.rs @@ -98,7 +98,7 @@ macro_rules! state_packets { fn write(self, buf: &mut W) -> Result<(), Error> { $( if true $(&& ($cond(&self)))* { - try!(self.$field.write_to(buf)); + self.$field.write_to(buf)?; } )+ @@ -127,7 +127,7 @@ macro_rules! state_packets { let mut packet : $name = $name::default(); $( if true $(&& ($cond(&packet)))* { - packet.$field = try!(Serializable::read_from(&mut buf)); + packet.$field = Serializable::read_from(&mut buf)?; } )+ Result::Ok(Option::Some(Packet::$name(packet))) @@ -155,7 +155,7 @@ pub trait Serializable: Sized { impl Serializable for Vec { fn read_from(buf: &mut R) -> Result, Error> { let mut v = Vec::new(); - try!(buf.read_to_end(&mut v)); + buf.read_to_end(&mut v)?; Ok(v) } @@ -166,23 +166,23 @@ impl Serializable for Vec { impl Serializable for Option{ fn read_from(buf: &mut R) -> Result, Error> { - let ty = try!(buf.read_u8()); + let ty = buf.read_u8()?; if ty == 0 { Result::Ok(None) } else { - let name = try!(nbt::read_string(buf)); - let tag = try!(nbt::Tag::read_from(buf)); + let name = nbt::read_string(buf)?; + let tag = nbt::Tag::read_from(buf)?; Result::Ok(Some(nbt::NamedTag(name, tag))) } } fn write_to(&self, buf: &mut W) -> Result<(), Error> { match *self { Some(ref val) => { - try!(buf.write_u8(10)); - try!(nbt::write_string(buf, &val.0)); - try!(val.1.write_to(buf)); + buf.write_u8(10)?; + nbt::write_string(buf, &val.0)?; + val.1.write_to(buf)?; } - None => try!(buf.write_u8(0)), + None => buf.write_u8(0)?, } Result::Ok(()) } @@ -190,11 +190,11 @@ impl Serializable for Option{ impl Serializable for Option where T : Serializable { fn read_from(buf: &mut R) -> Result, Error> { - Result::Ok(Some(try!(T::read_from(buf)))) + Result::Ok(Some(T::read_from(buf)?)) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { if self.is_some() { - try!(self.as_ref().unwrap().write_to(buf)); + self.as_ref().unwrap().write_to(buf)?; } Result::Ok(()) } @@ -206,30 +206,30 @@ impl Serializable for String { debug_assert!(len >= 0, "Negative string length: {}", len); debug_assert!(len <= 65536, "String length too big: {}", len); 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) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { let bytes = self.as_bytes(); - try!(VarInt(bytes.len() as i32).write_to(buf)); - try!(buf.write_all(bytes)); + VarInt(bytes.len() as i32).write_to(buf)?; + buf.write_all(bytes)?; Result::Ok(()) } } impl Serializable for format::Component { fn read_from(buf: &mut R) -> Result { - let len = try!(VarInt::read_from(buf)).0; + let len = VarInt::read_from(buf)?.0; 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)?; let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap(); Result::Ok(Self::from_value(&val)) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { let val = serde_json::to_string(&self.to_value()).unwrap(); let bytes = val.as_bytes(); - try!(VarInt(bytes.len() as i32).write_to(buf)); - try!(buf.write_all(bytes)); + VarInt(bytes.len() as i32).write_to(buf)?; + buf.write_all(bytes)?; Result::Ok(()) } } @@ -245,104 +245,104 @@ impl Serializable for () { impl Serializable for bool { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_u8()) != 0) + Result::Ok(buf.read_u8()? != 0) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_u8(if *self { + buf.write_u8(if *self { 1 } else { 0 - })); + })?; Result::Ok(()) } } impl Serializable for i8 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_i8())) + Result::Ok(buf.read_i8()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_i8(*self)); + buf.write_i8(*self)?; Result::Ok(()) } } impl Serializable for i16 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_i16::())) + Result::Ok(buf.read_i16::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_i16::(*self)); + buf.write_i16::(*self)?; Result::Ok(()) } } impl Serializable for i32 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_i32::())) + Result::Ok(buf.read_i32::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_i32::(*self)); + buf.write_i32::(*self)?; Result::Ok(()) } } impl Serializable for i64 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_i64::())) + Result::Ok(buf.read_i64::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_i64::(*self)); + buf.write_i64::(*self)?; Result::Ok(()) } } impl Serializable for u8 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_u8())) + Result::Ok(buf.read_u8()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_u8(*self)); + buf.write_u8(*self)?; Result::Ok(()) } } impl Serializable for u16 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_u16::())) + Result::Ok(buf.read_u16::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_u16::(*self)); + buf.write_u16::(*self)?; Result::Ok(()) } } impl Serializable for u64 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_u64::())) + Result::Ok(buf.read_u64::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_u64::(*self)); + buf.write_u64::(*self)?; Result::Ok(()) } } impl Serializable for f32 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_f32::())) + Result::Ok(buf.read_f32::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_f32::(*self)); + buf.write_f32::(*self)?; Result::Ok(()) } } impl Serializable for f64 { fn read_from(buf: &mut R) -> Result { - Result::Ok(try!(buf.read_f64::())) + Result::Ok(buf.read_f64::()?) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_f64::(*self)); + buf.write_f64::(*self)?; Result::Ok(()) } } @@ -380,12 +380,12 @@ impl Default for UUID { impl Serializable for UUID { fn read_from(buf: &mut R) -> Result { - Result::Ok(UUID(try!(buf.read_u64::()), - try!(buf.read_u64::()))) + Result::Ok(UUID(buf.read_u64::()?, + buf.read_u64::()?)) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(buf.write_u64::(self.0)); - try!(buf.write_u64::(self.1)); + buf.write_u64::(self.0)?; + buf.write_u64::(self.1)?; Result::Ok(()) } } @@ -412,11 +412,11 @@ impl LenPrefixed { impl Serializable for LenPrefixed { fn read_from(buf: &mut R) -> Result, Error> { - let len_data: L = try!(Serializable::read_from(buf)); + let len_data: L = Serializable::read_from(buf)?; let len: usize = len_data.into(); let mut data: Vec = Vec::with_capacity(len); for _ in 0..len { - data.push(try!(Serializable::read_from(buf))); + data.push(Serializable::read_from(buf)?); } Result::Ok(LenPrefixed { len: len_data, @@ -426,10 +426,10 @@ impl Serializable for LenPrefixed { fn write_to(&self, buf: &mut W) -> Result<(), Error> { let len_data: L = L::from(self.data.len()); - try!(len_data.write_to(buf)); + len_data.write_to(buf)?; let data = &self.data; for val in data { - try!(val.write_to(buf)); + val.write_to(buf)?; } Result::Ok(()) } @@ -468,10 +468,10 @@ impl LenPrefixedBytes { impl Serializable for LenPrefixedBytes { fn read_from(buf: &mut R) -> Result, Error> { - let len_data: L = try!(Serializable::read_from(buf)); + let len_data: L = Serializable::read_from(buf)?; let len: usize = len_data.into(); let mut data: Vec = Vec::with_capacity(len); - try!(buf.take(len as u64).read_to_end(&mut data)); + buf.take(len as u64).read_to_end(&mut data)?; Result::Ok(LenPrefixedBytes { len: len_data, data: data, @@ -480,8 +480,8 @@ impl Serializable for LenPrefixedBytes { fn write_to(&self, buf: &mut W) -> Result<(), Error> { let len_data: L = L::from(self.data.len()); - try!(len_data.write_to(buf)); - try!(buf.write_all(&self.data[..])); + len_data.write_to(buf)?; + buf.write_all(&self.data[..])?; Result::Ok(()) } } @@ -544,7 +544,7 @@ impl Serializable for VarInt { let mut size = 0; let mut val = 0u32; loop { - let b = try!(buf.read_u8()) as u32; + let b = buf.read_u8()? as u32; val |= (b & PART) << (size * 7); size += 1; if size > 5 { @@ -564,10 +564,10 @@ impl Serializable for VarInt { let mut val = self.0 as u32; loop { if (val & !PART) == 0 { - try!(buf.write_u8(val as u8)); + buf.write_u8(val as u8)?; return Result::Ok(()); } - try!(buf.write_u8(((val & PART) | 0x80) as u8)); + buf.write_u8(((val & PART) | 0x80) as u8)?; val >>= 7; } } @@ -607,7 +607,7 @@ impl Serializable for VarLong { let mut size = 0; let mut val = 0u64; loop { - let b = try!(buf.read_u8()) as u64; + let b = buf.read_u8()? as u64; val |= (b & PART) << (size * 7); size += 1; if size > 10 { @@ -627,10 +627,10 @@ impl Serializable for VarLong { let mut val = self.0 as u64; loop { if (val & !PART) == 0 { - try!(buf.write_u8(val as u8)); + buf.write_u8(val as u8)?; return Result::Ok(()); } - try!(buf.write_u8(((val & PART) | 0x80) as u8)); + buf.write_u8(((val & PART) | 0x80) as u8)?; val >>= 7; } } @@ -650,7 +650,7 @@ impl fmt::Debug for VarLong { impl Serializable for Position { fn read_from(buf: &mut R) -> Result { - let pos = try!(buf.read_u64::()); + let pos = buf.read_u64::()?; Ok(Position::new( ((pos as i64) >> 38) as i32, (((pos as i64) >> 26) & 0xFFF) as i32, @@ -661,7 +661,7 @@ impl Serializable for Position { let pos = (((self.x as u64) & 0x3FFFFFF) << 38) | (((self.y as u64) & 0xFFF) << 26) | ((self.z as u64) & 0x3FFFFFF); - try!(buf.write_u64::(pos)); + buf.write_u64::(pos)?; Result::Ok(()) } } @@ -763,7 +763,7 @@ impl Conn { } else { format!("{}:{}", parts[0], parts[1]) }; - let stream = try!(TcpStream::connect(&*address)); + let stream = TcpStream::connect(&*address)?; Result::Ok(Conn { stream: stream, host: parts[0].to_owned(), @@ -779,8 +779,8 @@ impl Conn { pub fn write_packet(&mut self, packet: T) -> Result<(), Error> { let mut buf = Vec::new(); - try!(VarInt(packet.packet_id()).write_to(&mut buf)); - try!(packet.write(&mut buf)); + VarInt(packet.packet_id()).write_to(&mut buf)?; + packet.write(&mut buf)?; let mut extra = if self.compression_threshold >= 0 { 1 @@ -794,26 +794,26 @@ impl Conn { extra = 0; let uncompressed_size = buf.len(); let mut new = Vec::new(); - try!(VarInt(uncompressed_size as i32).write_to(&mut new)); + VarInt(uncompressed_size as i32).write_to(&mut new)?; let write = self.compression_write.as_mut().unwrap(); write.reset(io::Cursor::new(buf)); - try!(write.read_to_end(&mut new)); + write.read_to_end(&mut new)?; buf = new; } - try!(VarInt(buf.len() as i32 + extra).write_to(self)); + VarInt(buf.len() as i32 + extra).write_to(self)?; if self.compression_threshold >= 0 && extra == 1 { - try!(VarInt(0).write_to(self)); + VarInt(0).write_to(self)?; } - try!(self.write_all(&buf)); + self.write_all(&buf)?; Result::Ok(()) } pub fn read_packet(&mut self) -> Result { - let len = try!(VarInt::read_from(self)).0 as usize; + let len = VarInt::read_from(self)?.0 as usize; let mut ibuf = vec![0; len]; - try!(self.read_exact(&mut ibuf)); + self.read_exact(&mut ibuf)?; let mut buf = io::Cursor::new(ibuf); @@ -821,25 +821,25 @@ impl Conn { if self.compression_read.is_none() { self.compression_read = Some(ZlibDecoder::new(io::Cursor::new(Vec::new()))); } - let uncompressed_size = try!(VarInt::read_from(&mut buf)).0; + let uncompressed_size = VarInt::read_from(&mut buf)?.0; if uncompressed_size != 0 { let mut new = Vec::with_capacity(uncompressed_size as usize); { let reader = self.compression_read.as_mut().unwrap(); reader.reset(buf); - try!(reader.read_to_end(&mut new)); + reader.read_to_end(&mut new)?; } buf = io::Cursor::new(new); } } - let id = try!(VarInt::read_from(&mut buf)).0; + let id = VarInt::read_from(&mut buf)?.0; let dir = match self.direction { Direction::Clientbound => Direction::Serverbound, Direction::Serverbound => Direction::Clientbound, }; - let packet = try!(packet::packet_by_id(self.state, dir, id, &mut buf)); + let packet = packet::packet_by_id(self.state, dir, id, &mut buf)?; match packet { Some(val) => { @@ -873,26 +873,26 @@ impl Conn { use self::packet::Packet; let host = self.host.clone(); let port = self.port; - try!(self.write_packet(Handshake { + self.write_packet(Handshake { protocol_version: VarInt(SUPPORTED_PROTOCOL), host: host, port: port, next: VarInt(1), - })); + })?; self.state = State::Status; - try!(self.write_packet(StatusRequest { empty: () })); + self.write_packet(StatusRequest { empty: () })?; - let status = if let Packet::StatusResponse(res) = try!(self.read_packet()) { + let status = if let Packet::StatusResponse(res) = self.read_packet()? { res.status } else { return Err(Error::Err("Wrong packet".to_owned())); }; let start = Instant::now(); - try!(self.write_packet(StatusPing { ping: 42 })); + self.write_packet(StatusPing { ping: 42 })?; - if let Packet::StatusPong(_) = try!(self.read_packet()) { + if let Packet::StatusPong(_) = self.read_packet()? { } else { return Err(Error::Err("Wrong packet".to_owned())); }; @@ -906,28 +906,28 @@ impl Conn { let invalid_status = || Error::Err("Invalid status".to_owned()); - let version = try!(val.get("version").ok_or(invalid_status())); - let players = try!(val.get("players").ok_or(invalid_status())); + let version = val.get("version").ok_or(invalid_status())?; + let players = val.get("players").ok_or(invalid_status())?; Ok((Status { version: StatusVersion { - name: try!(version.get("name").and_then(Value::as_str).ok_or(invalid_status())) + name: version.get("name").and_then(Value::as_str).ok_or(invalid_status())? .to_owned(), - protocol: try!(version.get("protocol") + protocol: version.get("protocol") .and_then(Value::as_i64) - .ok_or(invalid_status())) as i32, + .ok_or(invalid_status())? as i32, }, players: StatusPlayers { - max: try!(players.get("max") + max: players.get("max") .and_then(Value::as_i64) - .ok_or(invalid_status())) as i32, - online: try!(players.get("online") + .ok_or(invalid_status())? as i32, + online: players.get("online") .and_then(Value::as_i64) - .ok_or(invalid_status())) as i32, + .ok_or(invalid_status())? as i32, sample: Vec::new(), /* TODO */ }, - description: format::Component::from_value(try!(val.get("description") - .ok_or(invalid_status()))), + description: format::Component::from_value(val.get("description") + .ok_or(invalid_status())?), favicon: val.get("favicon").and_then(Value::as_str).map(|v| v.to_owned()), }, ping)) @@ -966,7 +966,7 @@ impl Read for Conn { match self.cipher.as_mut() { Option::None => self.stream.read(buf), Option::Some(cipher) => { - let ret = try!(self.stream.read(buf)); + let ret = self.stream.read(buf)?; cipher.decrypt(&mut buf[..ret]); Ok(ret) @@ -988,7 +988,7 @@ impl Write for Conn { cipher.encrypt(&mut data); - try!(self.stream.write_all(&data)); + self.stream.write_all(&data)?; Ok(buf.len()) } } diff --git a/protocol/src/protocol/mojang.rs b/protocol/src/protocol/mojang.rs index d546363..a0c7704 100644 --- a/protocol/src/protocol/mojang.rs +++ b/protocol/src/protocol/mojang.rs @@ -38,7 +38,7 @@ impl Profile { "name": "Minecraft", "version": 1 }}); - let req = try!(serde_json::to_string(&req_msg)); + let req = serde_json::to_string(&req_msg)?; let client = reqwest::Client::new(); let res = client.post(LOGIN_URL) @@ -46,7 +46,7 @@ impl Profile { .body(req) .send()?; - let ret: serde_json::Value = try!(serde_json::from_reader(res)); + let ret: serde_json::Value = serde_json::from_reader(res)?; if let Some(error) = ret.get("error").and_then(|v| v.as_str()) { return Err(super::Error::Err(format!( "{}: {}", @@ -66,7 +66,7 @@ impl Profile { "accessToken": self.access_token.clone(), "clientToken": token }); - let req = try!(serde_json::to_string(&req_msg)); + let req = serde_json::to_string(&req_msg)?; let client = reqwest::Client::new(); let res = client.post(VALIDATE_URL) @@ -75,14 +75,14 @@ impl Profile { .send()?; if res.status() != reqwest::StatusCode::NO_CONTENT { - let req = try!(serde_json::to_string(&req_msg)); // TODO: fix parsing twice to avoid move + let req = serde_json::to_string(&req_msg)?; // TODO: fix parsing twice to avoid move // Refresh needed let res = client.post(REFRESH_URL) .header(reqwest::header::CONTENT_TYPE, "application/json") .body(req) .send()?; - let ret: serde_json::Value = try!(serde_json::from_reader(res)); + let ret: serde_json::Value = serde_json::from_reader(res)?; if let Some(error) = ret.get("error").and_then(|v| v.as_str()) { return Err(super::Error::Err(format!( "{}: {}", diff --git a/protocol/src/protocol/packet.rs b/protocol/src/protocol/packet.rs index fb4613f..6e1a943 100644 --- a/protocol/src/protocol/packet.rs +++ b/protocol/src/protocol/packet.rs @@ -953,13 +953,13 @@ pub struct Statistic { impl Serializable for Statistic { fn read_from(buf: &mut R) -> Result { Ok(Statistic { - name: try!(Serializable::read_from(buf)), - value: try!(Serializable::read_from(buf)), + name: Serializable::read_from(buf)?, + value: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.name.write_to(buf)); + self.name.write_to(buf)?; self.value.write_to(buf) } } @@ -974,15 +974,15 @@ pub struct BlockChangeRecord { impl Serializable for BlockChangeRecord { fn read_from(buf: &mut R) -> Result { Ok(BlockChangeRecord { - xz: try!(Serializable::read_from(buf)), - y: try!(Serializable::read_from(buf)), - block_id: try!(Serializable::read_from(buf)), + xz: Serializable::read_from(buf)?, + y: Serializable::read_from(buf)?, + block_id: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.xz.write_to(buf)); - try!(self.y.write_to(buf)); + self.xz.write_to(buf)?; + self.y.write_to(buf)?; self.block_id.write_to(buf) } } @@ -997,15 +997,15 @@ pub struct ExplosionRecord { impl Serializable for ExplosionRecord { fn read_from(buf: &mut R) -> Result { Ok(ExplosionRecord { - x: try!(Serializable::read_from(buf)), - y: try!(Serializable::read_from(buf)), - z: try!(Serializable::read_from(buf)), + x: Serializable::read_from(buf)?, + y: Serializable::read_from(buf)?, + z: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.x.write_to(buf)); - try!(self.y.write_to(buf)); + self.x.write_to(buf)?; + self.y.write_to(buf)?; self.z.write_to(buf) } } @@ -1020,15 +1020,15 @@ pub struct MapIcon { impl Serializable for MapIcon { fn read_from(buf: &mut R) -> Result { Ok(MapIcon { - direction_type: try!(Serializable::read_from(buf)), - x: try!(Serializable::read_from(buf)), - z: try!(Serializable::read_from(buf)), + direction_type: Serializable::read_from(buf)?, + x: Serializable::read_from(buf)?, + z: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.direction_type.write_to(buf)); - try!(self.x.write_to(buf)); + self.direction_type.write_to(buf)?; + self.x.write_to(buf)?; self.z.write_to(buf) } } @@ -1053,15 +1053,15 @@ pub struct EntityProperty { impl Serializable for EntityProperty { fn read_from(buf: &mut R) -> Result { Ok(EntityProperty { - key: try!(Serializable::read_from(buf)), - value: try!(Serializable::read_from(buf)), - modifiers: try!(Serializable::read_from(buf)), + key: Serializable::read_from(buf)?, + value: Serializable::read_from(buf)?, + modifiers: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.key.write_to(buf)); - try!(self.value.write_to(buf)); + self.key.write_to(buf)?; + self.value.write_to(buf)?; self.modifiers.write_to(buf) } } @@ -1076,15 +1076,15 @@ pub struct PropertyModifier { impl Serializable for PropertyModifier { fn read_from(buf: &mut R) -> Result { Ok(PropertyModifier { - uuid: try!(Serializable::read_from(buf)), - amount: try!(Serializable::read_from(buf)), - operation: try!(Serializable::read_from(buf)), + uuid: Serializable::read_from(buf)?, + amount: Serializable::read_from(buf)?, + operation: Serializable::read_from(buf)?, }) } fn write_to(&self, buf: &mut W) -> Result<(), Error> { - try!(self.uuid.write_to(buf)); - try!(self.amount.write_to(buf)); + self.uuid.write_to(buf)?; + self.amount.write_to(buf)?; self.operation.write_to(buf) } } @@ -1098,25 +1098,25 @@ pub struct PlayerInfoData { impl Serializable for PlayerInfoData { fn read_from(buf: &mut R) -> Result { let mut m = PlayerInfoData { - action: try!(Serializable::read_from(buf)), + action: Serializable::read_from(buf)?, players: Vec::new(), }; - let len = try!(VarInt::read_from(buf)); + let len = VarInt::read_from(buf)?; for _ in 0..len.0 { - let uuid = try!(UUID::read_from(buf)); + let uuid = UUID::read_from(buf)?; match m.action.0 { 0 => { - let name = try!(String::read_from(buf)); + let name = String::read_from(buf)?; let mut props = Vec::new(); - let plen = try!(VarInt::read_from(buf)).0; + let plen = VarInt::read_from(buf)?.0; for _ in 0..plen { let mut prop = PlayerProperty { - name: try!(String::read_from(buf)), - value: try!(String::read_from(buf)), + name: String::read_from(buf)?, + value: String::read_from(buf)?, signature: Default::default(), }; - if try!(bool::read_from(buf)) { - prop.signature = Some(try!(String::read_from(buf))); + if bool::read_from(buf)? { + prop.signature = Some(String::read_from(buf)?); } props.push(prop); } @@ -1124,11 +1124,11 @@ impl Serializable for PlayerInfoData { uuid: uuid, name: name, properties: props, - gamemode: try!(Serializable::read_from(buf)), - ping: try!(Serializable::read_from(buf)), + gamemode: Serializable::read_from(buf)?, + ping: Serializable::read_from(buf)?, display: { - if try!(bool::read_from(buf)) { - Some(try!(Serializable::read_from(buf))) + if bool::read_from(buf)? { + Some(Serializable::read_from(buf)?) } else { None } @@ -1139,21 +1139,21 @@ impl Serializable for PlayerInfoData { 1 => { m.players.push(PlayerDetail::UpdateGamemode { uuid: uuid, - gamemode: try!(Serializable::read_from(buf)), + gamemode: Serializable::read_from(buf)?, }) } 2 => { m.players.push(PlayerDetail::UpdateLatency { uuid: uuid, - ping: try!(Serializable::read_from(buf)), + ping: Serializable::read_from(buf)?, }) } 3 => { m.players.push(PlayerDetail::UpdateDisplayName { uuid: uuid, display: { - if try!(bool::read_from(buf)) { - Some(try!(Serializable::read_from(buf))) + if bool::read_from(buf)? { + Some(Serializable::read_from(buf)?) } else { None }