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
fc18e9836f
commit
db02f9e790
|
@ -147,10 +147,10 @@ impl TextComponent {
|
||||||
|
|
||||||
impl fmt::Display for TextComponent {
|
impl fmt::Display for TextComponent {
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
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 {
|
if let Some(ref extra) = self.modifier.extra {
|
||||||
for c in extra {
|
for c in extra {
|
||||||
try!(write!(f, "{}", c));
|
write!(f, "{}", c)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
|
|
18
src/item.rs
18
src/item.rs
|
@ -39,26 +39,26 @@ impl Default for Stack {
|
||||||
|
|
||||||
impl Serializable for Option<Stack> {
|
impl Serializable for Option<Stack> {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<Stack>, protocol::Error> {
|
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 {
|
if id == -1 {
|
||||||
return Ok(None);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
Ok(Some(Stack {
|
Ok(Some(Stack {
|
||||||
id: id as isize,
|
id: id as isize,
|
||||||
count: try!(buf.read_u8()) as isize,
|
count: buf.read_u8()? as isize,
|
||||||
damage: try!(buf.read_i16::<BigEndian>()) as isize,
|
damage: buf.read_i16::<BigEndian>()? as isize,
|
||||||
tag: try!(Serializable::read_from(buf)),
|
tag: Serializable::read_from(buf)?,
|
||||||
}))
|
}))
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||||
match *self {
|
match *self {
|
||||||
Some(ref val) => {
|
Some(ref val) => {
|
||||||
try!(buf.write_i16::<BigEndian>(val.id as i16));
|
buf.write_i16::<BigEndian>(val.id as i16)?;
|
||||||
try!(buf.write_u8(val.count as u8));
|
buf.write_u8(val.count as u8)?;
|
||||||
try!(buf.write_i16::<BigEndian>(val.damage as i16));
|
buf.write_i16::<BigEndian>(val.damage as i16)?;
|
||||||
try!(val.tag.write_to(buf));
|
val.tag.write_to(buf)?;
|
||||||
}
|
}
|
||||||
None => try!(buf.write_i16::<BigEndian>(-1)),
|
None => buf.write_i16::<BigEndian>(-1)?,
|
||||||
}
|
}
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
|
|
|
@ -175,45 +175,45 @@ impl Tag {
|
||||||
fn read_type<R: io::Read>(id: u8, buf: &mut R) -> Result<Tag, protocol::Error> {
|
fn read_type<R: io::Read>(id: u8, buf: &mut R) -> Result<Tag, protocol::Error> {
|
||||||
match id {
|
match id {
|
||||||
0 => unreachable!(),
|
0 => unreachable!(),
|
||||||
1 => Ok(Tag::Byte(try!(buf.read_i8()))),
|
1 => Ok(Tag::Byte(buf.read_i8()?)),
|
||||||
2 => Ok(Tag::Short(try!(buf.read_i16::<BigEndian>()))),
|
2 => Ok(Tag::Short(buf.read_i16::<BigEndian>()?)),
|
||||||
3 => Ok(Tag::Int(try!(buf.read_i32::<BigEndian>()))),
|
3 => Ok(Tag::Int(buf.read_i32::<BigEndian>()?)),
|
||||||
4 => Ok(Tag::Long(try!(buf.read_i64::<BigEndian>()))),
|
4 => Ok(Tag::Long(buf.read_i64::<BigEndian>()?)),
|
||||||
5 => Ok(Tag::Float(try!(buf.read_f32::<BigEndian>()))),
|
5 => Ok(Tag::Float(buf.read_f32::<BigEndian>()?)),
|
||||||
6 => Ok(Tag::Double(try!(buf.read_f64::<BigEndian>()))),
|
6 => Ok(Tag::Double(buf.read_f64::<BigEndian>()?)),
|
||||||
7 => Ok(Tag::ByteArray({
|
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);
|
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
|
data
|
||||||
})),
|
})),
|
||||||
8 => Ok(Tag::String(try!(read_string(buf)))),
|
8 => Ok(Tag::String(read_string(buf)?)),
|
||||||
9 => {
|
9 => {
|
||||||
let mut l = Vec::new();
|
let mut l = Vec::new();
|
||||||
let ty = try!(buf.read_u8());
|
let ty = buf.read_u8()?;
|
||||||
let len: i32 = try!(Serializable::read_from(buf));
|
let len: i32 = Serializable::read_from(buf)?;
|
||||||
for _ in 0..len {
|
for _ in 0..len {
|
||||||
l.push(try!(Tag::read_type(ty, buf)));
|
l.push(Tag::read_type(ty, buf)?);
|
||||||
}
|
}
|
||||||
Ok(Tag::List(l))
|
Ok(Tag::List(l))
|
||||||
}
|
}
|
||||||
10 => {
|
10 => {
|
||||||
let mut c = Tag::new_compound();
|
let mut c = Tag::new_compound();
|
||||||
loop {
|
loop {
|
||||||
let ty = try!(buf.read_u8());
|
let ty = buf.read_u8()?;
|
||||||
if ty == 0 {
|
if ty == 0 {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
let name: String = try!(read_string(buf));
|
let name: String = read_string(buf)?;
|
||||||
c.put(&name[..], try!(Tag::read_type(ty, buf)));
|
c.put(&name[..], Tag::read_type(ty, buf)?);
|
||||||
}
|
}
|
||||||
Ok(c)
|
Ok(c)
|
||||||
}
|
}
|
||||||
11 => Ok(Tag::IntArray({
|
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);
|
let mut data = Vec::with_capacity(len as usize);
|
||||||
for _ in 0..len {
|
for _ in 0..len {
|
||||||
data.push(try!(buf.read_i32::<BigEndian>()));
|
data.push(buf.read_i32::<BigEndian>()?);
|
||||||
}
|
}
|
||||||
data
|
data
|
||||||
})),
|
})),
|
||||||
|
@ -230,41 +230,41 @@ impl Serializable for Tag {
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||||
match *self {
|
match *self {
|
||||||
Tag::End => {}
|
Tag::End => {}
|
||||||
Tag::Byte(val) => try!(buf.write_i8(val)),
|
Tag::Byte(val) => buf.write_i8(val)?,
|
||||||
Tag::Short(val) => try!(buf.write_i16::<BigEndian>(val)),
|
Tag::Short(val) => buf.write_i16::<BigEndian>(val)?,
|
||||||
Tag::Int(val) => try!(buf.write_i32::<BigEndian>(val)),
|
Tag::Int(val) => buf.write_i32::<BigEndian>(val)?,
|
||||||
Tag::Long(val) => try!(buf.write_i64::<BigEndian>(val)),
|
Tag::Long(val) => buf.write_i64::<BigEndian>(val)?,
|
||||||
Tag::Float(val) => try!(buf.write_f32::<BigEndian>(val)),
|
Tag::Float(val) => buf.write_f32::<BigEndian>(val)?,
|
||||||
Tag::Double(val) => try!(buf.write_f64::<BigEndian>(val)),
|
Tag::Double(val) => buf.write_f64::<BigEndian>(val)?,
|
||||||
Tag::ByteArray(ref val) => {
|
Tag::ByteArray(ref val) => {
|
||||||
try!((val.len() as i32).write_to(buf));
|
(val.len() as i32).write_to(buf)?;
|
||||||
try!(buf.write_all(val));
|
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) => {
|
Tag::List(ref val) => {
|
||||||
if val.is_empty() {
|
if val.is_empty() {
|
||||||
try!(buf.write_u8(0));
|
buf.write_u8(0)?;
|
||||||
try!(buf.write_i32::<BigEndian>(0));
|
buf.write_i32::<BigEndian>(0)?;
|
||||||
} else {
|
} else {
|
||||||
try!(buf.write_u8(val[0].internal_id()));
|
buf.write_u8(val[0].internal_id())?;
|
||||||
try!(buf.write_i32::<BigEndian>(val.len() as i32));
|
buf.write_i32::<BigEndian>(val.len() as i32)?;
|
||||||
for e in val {
|
for e in val {
|
||||||
try!(e.write_to(buf));
|
e.write_to(buf)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Tag::Compound(ref val) => {
|
Tag::Compound(ref val) => {
|
||||||
for (k, v) in val {
|
for (k, v) in val {
|
||||||
try!(v.internal_id().write_to(buf));
|
v.internal_id().write_to(buf)?;
|
||||||
try!(write_string(buf, k));
|
write_string(buf, k)?;
|
||||||
try!(v.write_to(buf));
|
v.write_to(buf)?;
|
||||||
}
|
}
|
||||||
try!(buf.write_u8(0));
|
buf.write_u8(0)?;
|
||||||
}
|
}
|
||||||
Tag::IntArray(ref val) => {
|
Tag::IntArray(ref val) => {
|
||||||
try!((val.len() as i32).write_to(buf));
|
(val.len() as i32).write_to(buf)?;
|
||||||
for v in val {
|
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> {
|
pub fn write_string<W: io::Write>(buf: &mut W, s: &str) -> Result<(), protocol::Error> {
|
||||||
let data = s.as_bytes();
|
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())
|
buf.write_all(data).map_err(|v| v.into())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn read_string<R: io::Read>(buf: &mut R) -> Result<String, protocol::Error> {
|
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();
|
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)
|
Result::Ok(ret)
|
||||||
}
|
}
|
||||||
|
|
|
@ -98,7 +98,7 @@ macro_rules! state_packets {
|
||||||
fn write<W: io::Write>(self, buf: &mut W) -> Result<(), Error> {
|
fn write<W: io::Write>(self, buf: &mut W) -> Result<(), Error> {
|
||||||
$(
|
$(
|
||||||
if true $(&& ($cond(&self)))* {
|
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();
|
let mut packet : $name = $name::default();
|
||||||
$(
|
$(
|
||||||
if true $(&& ($cond(&packet)))* {
|
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)))
|
Result::Ok(Option::Some(Packet::$name(packet)))
|
||||||
|
@ -155,7 +155,7 @@ pub trait Serializable: Sized {
|
||||||
impl Serializable for Vec<u8> {
|
impl Serializable for Vec<u8> {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Vec<u8>, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Vec<u8>, Error> {
|
||||||
let mut v = Vec::new();
|
let mut v = Vec::new();
|
||||||
try!(buf.read_to_end(&mut v));
|
buf.read_to_end(&mut v)?;
|
||||||
Ok(v)
|
Ok(v)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -166,23 +166,23 @@ impl Serializable for Vec<u8> {
|
||||||
|
|
||||||
impl Serializable for Option<nbt::NamedTag>{
|
impl Serializable for Option<nbt::NamedTag>{
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<nbt::NamedTag>, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<nbt::NamedTag>, Error> {
|
||||||
let ty = try!(buf.read_u8());
|
let ty = buf.read_u8()?;
|
||||||
if ty == 0 {
|
if ty == 0 {
|
||||||
Result::Ok(None)
|
Result::Ok(None)
|
||||||
} else {
|
} else {
|
||||||
let name = try!(nbt::read_string(buf));
|
let name = nbt::read_string(buf)?;
|
||||||
let tag = try!(nbt::Tag::read_from(buf));
|
let tag = nbt::Tag::read_from(buf)?;
|
||||||
Result::Ok(Some(nbt::NamedTag(name, tag)))
|
Result::Ok(Some(nbt::NamedTag(name, tag)))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
match *self {
|
match *self {
|
||||||
Some(ref val) => {
|
Some(ref val) => {
|
||||||
try!(buf.write_u8(10));
|
buf.write_u8(10)?;
|
||||||
try!(nbt::write_string(buf, &val.0));
|
nbt::write_string(buf, &val.0)?;
|
||||||
try!(val.1.write_to(buf));
|
val.1.write_to(buf)?;
|
||||||
}
|
}
|
||||||
None => try!(buf.write_u8(0)),
|
None => buf.write_u8(0)?,
|
||||||
}
|
}
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
|
@ -190,11 +190,11 @@ impl Serializable for Option<nbt::NamedTag>{
|
||||||
|
|
||||||
impl <T> Serializable for Option<T> where T : Serializable {
|
impl <T> Serializable for Option<T> where T : Serializable {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<T>, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<T>, Error> {
|
||||||
Result::Ok(Some(try!(T::read_from(buf))))
|
Result::Ok(Some(T::read_from(buf)?))
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
if self.is_some() {
|
if self.is_some() {
|
||||||
try!(self.as_ref().unwrap().write_to(buf));
|
self.as_ref().unwrap().write_to(buf)?;
|
||||||
}
|
}
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
|
@ -206,30 +206,30 @@ impl Serializable for String {
|
||||||
debug_assert!(len >= 0, "Negative string length: {}", len);
|
debug_assert!(len >= 0, "Negative string length: {}", len);
|
||||||
debug_assert!(len <= 65536, "String length too big: {}", len);
|
debug_assert!(len <= 65536, "String length too big: {}", len);
|
||||||
let mut ret = String::new();
|
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)
|
Result::Ok(ret)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
let bytes = self.as_bytes();
|
let bytes = self.as_bytes();
|
||||||
try!(VarInt(bytes.len() as i32).write_to(buf));
|
VarInt(bytes.len() as i32).write_to(buf)?;
|
||||||
try!(buf.write_all(bytes));
|
buf.write_all(bytes)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for format::Component {
|
impl Serializable for format::Component {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
let len = try!(VarInt::read_from(buf)).0;
|
let len = VarInt::read_from(buf)?.0;
|
||||||
let mut ret = String::new();
|
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();
|
let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap();
|
||||||
Result::Ok(Self::from_value(&val))
|
Result::Ok(Self::from_value(&val))
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
let val = serde_json::to_string(&self.to_value()).unwrap();
|
let val = serde_json::to_string(&self.to_value()).unwrap();
|
||||||
let bytes = val.as_bytes();
|
let bytes = val.as_bytes();
|
||||||
try!(VarInt(bytes.len() as i32).write_to(buf));
|
VarInt(bytes.len() as i32).write_to(buf)?;
|
||||||
try!(buf.write_all(bytes));
|
buf.write_all(bytes)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -245,104 +245,104 @@ impl Serializable for () {
|
||||||
|
|
||||||
impl Serializable for bool {
|
impl Serializable for bool {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<bool, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<bool, Error> {
|
||||||
Result::Ok(try!(buf.read_u8()) != 0)
|
Result::Ok(buf.read_u8()? != 0)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_u8(if *self {
|
buf.write_u8(if *self {
|
||||||
1
|
1
|
||||||
} else {
|
} else {
|
||||||
0
|
0
|
||||||
}));
|
})?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for i8 {
|
impl Serializable for i8 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<i8, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<i8, Error> {
|
||||||
Result::Ok(try!(buf.read_i8()))
|
Result::Ok(buf.read_i8()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_i8(*self));
|
buf.write_i8(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for i16 {
|
impl Serializable for i16 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<i16, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<i16, Error> {
|
||||||
Result::Ok(try!(buf.read_i16::<BigEndian>()))
|
Result::Ok(buf.read_i16::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_i16::<BigEndian>(*self));
|
buf.write_i16::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for i32 {
|
impl Serializable for i32 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<i32, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<i32, Error> {
|
||||||
Result::Ok(try!(buf.read_i32::<BigEndian>()))
|
Result::Ok(buf.read_i32::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_i32::<BigEndian>(*self));
|
buf.write_i32::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for i64 {
|
impl Serializable for i64 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<i64, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<i64, Error> {
|
||||||
Result::Ok(try!(buf.read_i64::<BigEndian>()))
|
Result::Ok(buf.read_i64::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_i64::<BigEndian>(*self));
|
buf.write_i64::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for u8 {
|
impl Serializable for u8 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<u8, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<u8, Error> {
|
||||||
Result::Ok(try!(buf.read_u8()))
|
Result::Ok(buf.read_u8()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_u8(*self));
|
buf.write_u8(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for u16 {
|
impl Serializable for u16 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<u16, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<u16, Error> {
|
||||||
Result::Ok(try!(buf.read_u16::<BigEndian>()))
|
Result::Ok(buf.read_u16::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_u16::<BigEndian>(*self));
|
buf.write_u16::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for u64 {
|
impl Serializable for u64 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<u64, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<u64, Error> {
|
||||||
Result::Ok(try!(buf.read_u64::<BigEndian>()))
|
Result::Ok(buf.read_u64::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_u64::<BigEndian>(*self));
|
buf.write_u64::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for f32 {
|
impl Serializable for f32 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<f32, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<f32, Error> {
|
||||||
Result::Ok(try!(buf.read_f32::<BigEndian>()))
|
Result::Ok(buf.read_f32::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_f32::<BigEndian>(*self));
|
buf.write_f32::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serializable for f64 {
|
impl Serializable for f64 {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<f64, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<f64, Error> {
|
||||||
Result::Ok(try!(buf.read_f64::<BigEndian>()))
|
Result::Ok(buf.read_f64::<BigEndian>()?)
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_f64::<BigEndian>(*self));
|
buf.write_f64::<BigEndian>(*self)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -380,12 +380,12 @@ impl Default for UUID {
|
||||||
|
|
||||||
impl Serializable for UUID {
|
impl Serializable for UUID {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<UUID, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<UUID, Error> {
|
||||||
Result::Ok(UUID(try!(buf.read_u64::<BigEndian>()),
|
Result::Ok(UUID(buf.read_u64::<BigEndian>()?,
|
||||||
try!(buf.read_u64::<BigEndian>())))
|
buf.read_u64::<BigEndian>()?))
|
||||||
}
|
}
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(buf.write_u64::<BigEndian>(self.0));
|
buf.write_u64::<BigEndian>(self.0)?;
|
||||||
try!(buf.write_u64::<BigEndian>(self.1));
|
buf.write_u64::<BigEndian>(self.1)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -412,11 +412,11 @@ impl <L: Lengthable, V: Default> LenPrefixed<L, V> {
|
||||||
|
|
||||||
impl <L: Lengthable, V: Serializable> Serializable for LenPrefixed<L, V> {
|
impl <L: Lengthable, V: Serializable> Serializable for LenPrefixed<L, V> {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixed<L, V>, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixed<L, V>, 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 len: usize = len_data.into();
|
||||||
let mut data: Vec<V> = Vec::with_capacity(len);
|
let mut data: Vec<V> = Vec::with_capacity(len);
|
||||||
for _ in 0..len {
|
for _ in 0..len {
|
||||||
data.push(try!(Serializable::read_from(buf)));
|
data.push(Serializable::read_from(buf)?);
|
||||||
}
|
}
|
||||||
Result::Ok(LenPrefixed {
|
Result::Ok(LenPrefixed {
|
||||||
len: len_data,
|
len: len_data,
|
||||||
|
@ -426,10 +426,10 @@ impl <L: Lengthable, V: Serializable> Serializable for LenPrefixed<L, V> {
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
let len_data: L = L::from(self.data.len());
|
let len_data: L = L::from(self.data.len());
|
||||||
try!(len_data.write_to(buf));
|
len_data.write_to(buf)?;
|
||||||
let data = &self.data;
|
let data = &self.data;
|
||||||
for val in data {
|
for val in data {
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
|
@ -468,10 +468,10 @@ impl <L: Lengthable> LenPrefixedBytes<L> {
|
||||||
|
|
||||||
impl <L: Lengthable> Serializable for LenPrefixedBytes<L> {
|
impl <L: Lengthable> Serializable for LenPrefixedBytes<L> {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixedBytes<L>, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixedBytes<L>, 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 len: usize = len_data.into();
|
||||||
let mut data: Vec<u8> = Vec::with_capacity(len);
|
let mut data: Vec<u8> = 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 {
|
Result::Ok(LenPrefixedBytes {
|
||||||
len: len_data,
|
len: len_data,
|
||||||
data: data,
|
data: data,
|
||||||
|
@ -480,8 +480,8 @@ impl <L: Lengthable> Serializable for LenPrefixedBytes<L> {
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
let len_data: L = L::from(self.data.len());
|
let len_data: L = L::from(self.data.len());
|
||||||
try!(len_data.write_to(buf));
|
len_data.write_to(buf)?;
|
||||||
try!(buf.write_all(&self.data[..]));
|
buf.write_all(&self.data[..])?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -544,7 +544,7 @@ impl Serializable for VarInt {
|
||||||
let mut size = 0;
|
let mut size = 0;
|
||||||
let mut val = 0u32;
|
let mut val = 0u32;
|
||||||
loop {
|
loop {
|
||||||
let b = try!(buf.read_u8()) as u32;
|
let b = buf.read_u8()? as u32;
|
||||||
val |= (b & PART) << (size * 7);
|
val |= (b & PART) << (size * 7);
|
||||||
size += 1;
|
size += 1;
|
||||||
if size > 5 {
|
if size > 5 {
|
||||||
|
@ -564,10 +564,10 @@ impl Serializable for VarInt {
|
||||||
let mut val = self.0 as u32;
|
let mut val = self.0 as u32;
|
||||||
loop {
|
loop {
|
||||||
if (val & !PART) == 0 {
|
if (val & !PART) == 0 {
|
||||||
try!(buf.write_u8(val as u8));
|
buf.write_u8(val as u8)?;
|
||||||
return Result::Ok(());
|
return Result::Ok(());
|
||||||
}
|
}
|
||||||
try!(buf.write_u8(((val & PART) | 0x80) as u8));
|
buf.write_u8(((val & PART) | 0x80) as u8)?;
|
||||||
val >>= 7;
|
val >>= 7;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -607,7 +607,7 @@ impl Serializable for VarLong {
|
||||||
let mut size = 0;
|
let mut size = 0;
|
||||||
let mut val = 0u64;
|
let mut val = 0u64;
|
||||||
loop {
|
loop {
|
||||||
let b = try!(buf.read_u8()) as u64;
|
let b = buf.read_u8()? as u64;
|
||||||
val |= (b & PART) << (size * 7);
|
val |= (b & PART) << (size * 7);
|
||||||
size += 1;
|
size += 1;
|
||||||
if size > 10 {
|
if size > 10 {
|
||||||
|
@ -627,10 +627,10 @@ impl Serializable for VarLong {
|
||||||
let mut val = self.0 as u64;
|
let mut val = self.0 as u64;
|
||||||
loop {
|
loop {
|
||||||
if (val & !PART) == 0 {
|
if (val & !PART) == 0 {
|
||||||
try!(buf.write_u8(val as u8));
|
buf.write_u8(val as u8)?;
|
||||||
return Result::Ok(());
|
return Result::Ok(());
|
||||||
}
|
}
|
||||||
try!(buf.write_u8(((val & PART) | 0x80) as u8));
|
buf.write_u8(((val & PART) | 0x80) as u8)?;
|
||||||
val >>= 7;
|
val >>= 7;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -650,7 +650,7 @@ impl fmt::Debug for VarLong {
|
||||||
|
|
||||||
impl Serializable for Position {
|
impl Serializable for Position {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Position, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Position, Error> {
|
||||||
let pos = try!(buf.read_u64::<BigEndian>());
|
let pos = buf.read_u64::<BigEndian>()?;
|
||||||
Ok(Position::new(
|
Ok(Position::new(
|
||||||
((pos as i64) >> 38) as i32,
|
((pos as i64) >> 38) as i32,
|
||||||
(((pos as i64) >> 26) & 0xFFF) 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)
|
let pos = (((self.x as u64) & 0x3FFFFFF) << 38)
|
||||||
| (((self.y as u64) & 0xFFF) << 26)
|
| (((self.y as u64) & 0xFFF) << 26)
|
||||||
| ((self.z as u64) & 0x3FFFFFF);
|
| ((self.z as u64) & 0x3FFFFFF);
|
||||||
try!(buf.write_u64::<BigEndian>(pos));
|
buf.write_u64::<BigEndian>(pos)?;
|
||||||
Result::Ok(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -763,7 +763,7 @@ impl Conn {
|
||||||
} else {
|
} else {
|
||||||
format!("{}:{}", parts[0], parts[1])
|
format!("{}:{}", parts[0], parts[1])
|
||||||
};
|
};
|
||||||
let stream = try!(TcpStream::connect(&*address));
|
let stream = TcpStream::connect(&*address)?;
|
||||||
Result::Ok(Conn {
|
Result::Ok(Conn {
|
||||||
stream: stream,
|
stream: stream,
|
||||||
host: parts[0].to_owned(),
|
host: parts[0].to_owned(),
|
||||||
|
@ -779,8 +779,8 @@ impl Conn {
|
||||||
|
|
||||||
pub fn write_packet<T: PacketType>(&mut self, packet: T) -> Result<(), Error> {
|
pub fn write_packet<T: PacketType>(&mut self, packet: T) -> Result<(), Error> {
|
||||||
let mut buf = Vec::new();
|
let mut buf = Vec::new();
|
||||||
try!(VarInt(packet.packet_id()).write_to(&mut buf));
|
VarInt(packet.packet_id()).write_to(&mut buf)?;
|
||||||
try!(packet.write(&mut buf));
|
packet.write(&mut buf)?;
|
||||||
|
|
||||||
let mut extra = if self.compression_threshold >= 0 {
|
let mut extra = if self.compression_threshold >= 0 {
|
||||||
1
|
1
|
||||||
|
@ -794,26 +794,26 @@ impl Conn {
|
||||||
extra = 0;
|
extra = 0;
|
||||||
let uncompressed_size = buf.len();
|
let uncompressed_size = buf.len();
|
||||||
let mut new = Vec::new();
|
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();
|
let write = self.compression_write.as_mut().unwrap();
|
||||||
write.reset(io::Cursor::new(buf));
|
write.reset(io::Cursor::new(buf));
|
||||||
try!(write.read_to_end(&mut new));
|
write.read_to_end(&mut new)?;
|
||||||
buf = 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 {
|
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(())
|
Result::Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn read_packet(&mut self) -> Result<packet::Packet, Error> {
|
pub fn read_packet(&mut self) -> Result<packet::Packet, Error> {
|
||||||
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];
|
let mut ibuf = vec![0; len];
|
||||||
try!(self.read_exact(&mut ibuf));
|
self.read_exact(&mut ibuf)?;
|
||||||
|
|
||||||
let mut buf = io::Cursor::new(ibuf);
|
let mut buf = io::Cursor::new(ibuf);
|
||||||
|
|
||||||
|
@ -821,25 +821,25 @@ impl Conn {
|
||||||
if self.compression_read.is_none() {
|
if self.compression_read.is_none() {
|
||||||
self.compression_read = Some(ZlibDecoder::new(io::Cursor::new(Vec::new())));
|
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 {
|
if uncompressed_size != 0 {
|
||||||
let mut new = Vec::with_capacity(uncompressed_size as usize);
|
let mut new = Vec::with_capacity(uncompressed_size as usize);
|
||||||
{
|
{
|
||||||
let reader = self.compression_read.as_mut().unwrap();
|
let reader = self.compression_read.as_mut().unwrap();
|
||||||
reader.reset(buf);
|
reader.reset(buf);
|
||||||
try!(reader.read_to_end(&mut new));
|
reader.read_to_end(&mut new)?;
|
||||||
}
|
}
|
||||||
buf = io::Cursor::new(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 {
|
let dir = match self.direction {
|
||||||
Direction::Clientbound => Direction::Serverbound,
|
Direction::Clientbound => Direction::Serverbound,
|
||||||
Direction::Serverbound => Direction::Clientbound,
|
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 {
|
match packet {
|
||||||
Some(val) => {
|
Some(val) => {
|
||||||
|
@ -873,26 +873,26 @@ impl Conn {
|
||||||
use self::packet::Packet;
|
use self::packet::Packet;
|
||||||
let host = self.host.clone();
|
let host = self.host.clone();
|
||||||
let port = self.port;
|
let port = self.port;
|
||||||
try!(self.write_packet(Handshake {
|
self.write_packet(Handshake {
|
||||||
protocol_version: VarInt(SUPPORTED_PROTOCOL),
|
protocol_version: VarInt(SUPPORTED_PROTOCOL),
|
||||||
host: host,
|
host: host,
|
||||||
port: port,
|
port: port,
|
||||||
next: VarInt(1),
|
next: VarInt(1),
|
||||||
}));
|
})?;
|
||||||
self.state = State::Status;
|
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
|
res.status
|
||||||
} else {
|
} else {
|
||||||
return Err(Error::Err("Wrong packet".to_owned()));
|
return Err(Error::Err("Wrong packet".to_owned()));
|
||||||
};
|
};
|
||||||
|
|
||||||
let start = Instant::now();
|
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 {
|
} else {
|
||||||
return Err(Error::Err("Wrong packet".to_owned()));
|
return Err(Error::Err("Wrong packet".to_owned()));
|
||||||
};
|
};
|
||||||
|
@ -906,28 +906,28 @@ impl Conn {
|
||||||
|
|
||||||
let invalid_status = || Error::Err("Invalid status".to_owned());
|
let invalid_status = || Error::Err("Invalid status".to_owned());
|
||||||
|
|
||||||
let version = try!(val.get("version").ok_or(invalid_status()));
|
let version = val.get("version").ok_or(invalid_status())?;
|
||||||
let players = try!(val.get("players").ok_or(invalid_status()));
|
let players = val.get("players").ok_or(invalid_status())?;
|
||||||
|
|
||||||
Ok((Status {
|
Ok((Status {
|
||||||
version: StatusVersion {
|
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(),
|
.to_owned(),
|
||||||
protocol: try!(version.get("protocol")
|
protocol: version.get("protocol")
|
||||||
.and_then(Value::as_i64)
|
.and_then(Value::as_i64)
|
||||||
.ok_or(invalid_status())) as i32,
|
.ok_or(invalid_status())? as i32,
|
||||||
},
|
},
|
||||||
players: StatusPlayers {
|
players: StatusPlayers {
|
||||||
max: try!(players.get("max")
|
max: players.get("max")
|
||||||
.and_then(Value::as_i64)
|
.and_then(Value::as_i64)
|
||||||
.ok_or(invalid_status())) as i32,
|
.ok_or(invalid_status())? as i32,
|
||||||
online: try!(players.get("online")
|
online: players.get("online")
|
||||||
.and_then(Value::as_i64)
|
.and_then(Value::as_i64)
|
||||||
.ok_or(invalid_status())) as i32,
|
.ok_or(invalid_status())? as i32,
|
||||||
sample: Vec::new(), /* TODO */
|
sample: Vec::new(), /* TODO */
|
||||||
},
|
},
|
||||||
description: format::Component::from_value(try!(val.get("description")
|
description: format::Component::from_value(val.get("description")
|
||||||
.ok_or(invalid_status()))),
|
.ok_or(invalid_status())?),
|
||||||
favicon: val.get("favicon").and_then(Value::as_str).map(|v| v.to_owned()),
|
favicon: val.get("favicon").and_then(Value::as_str).map(|v| v.to_owned()),
|
||||||
},
|
},
|
||||||
ping))
|
ping))
|
||||||
|
@ -966,7 +966,7 @@ impl Read for Conn {
|
||||||
match self.cipher.as_mut() {
|
match self.cipher.as_mut() {
|
||||||
Option::None => self.stream.read(buf),
|
Option::None => self.stream.read(buf),
|
||||||
Option::Some(cipher) => {
|
Option::Some(cipher) => {
|
||||||
let ret = try!(self.stream.read(buf));
|
let ret = self.stream.read(buf)?;
|
||||||
cipher.decrypt(&mut buf[..ret]);
|
cipher.decrypt(&mut buf[..ret]);
|
||||||
|
|
||||||
Ok(ret)
|
Ok(ret)
|
||||||
|
@ -988,7 +988,7 @@ impl Write for Conn {
|
||||||
|
|
||||||
cipher.encrypt(&mut data);
|
cipher.encrypt(&mut data);
|
||||||
|
|
||||||
try!(self.stream.write_all(&data));
|
self.stream.write_all(&data)?;
|
||||||
Ok(buf.len())
|
Ok(buf.len())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -38,7 +38,7 @@ impl Profile {
|
||||||
"name": "Minecraft",
|
"name": "Minecraft",
|
||||||
"version": 1
|
"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 client = reqwest::Client::new();
|
||||||
let res = client.post(LOGIN_URL)
|
let res = client.post(LOGIN_URL)
|
||||||
|
@ -46,7 +46,7 @@ impl Profile {
|
||||||
.body(req)
|
.body(req)
|
||||||
.send()?;
|
.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()) {
|
if let Some(error) = ret.get("error").and_then(|v| v.as_str()) {
|
||||||
return Err(super::Error::Err(format!(
|
return Err(super::Error::Err(format!(
|
||||||
"{}: {}",
|
"{}: {}",
|
||||||
|
@ -66,7 +66,7 @@ impl Profile {
|
||||||
"accessToken": self.access_token.clone(),
|
"accessToken": self.access_token.clone(),
|
||||||
"clientToken": token
|
"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 client = reqwest::Client::new();
|
||||||
let res = client.post(VALIDATE_URL)
|
let res = client.post(VALIDATE_URL)
|
||||||
|
@ -75,14 +75,14 @@ impl Profile {
|
||||||
.send()?;
|
.send()?;
|
||||||
|
|
||||||
if res.status() != reqwest::StatusCode::NO_CONTENT {
|
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
|
// Refresh needed
|
||||||
let res = client.post(REFRESH_URL)
|
let res = client.post(REFRESH_URL)
|
||||||
.header(reqwest::header::CONTENT_TYPE, "application/json")
|
.header(reqwest::header::CONTENT_TYPE, "application/json")
|
||||||
.body(req)
|
.body(req)
|
||||||
.send()?;
|
.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()) {
|
if let Some(error) = ret.get("error").and_then(|v| v.as_str()) {
|
||||||
return Err(super::Error::Err(format!(
|
return Err(super::Error::Err(format!(
|
||||||
"{}: {}",
|
"{}: {}",
|
||||||
|
|
|
@ -953,13 +953,13 @@ pub struct Statistic {
|
||||||
impl Serializable for Statistic {
|
impl Serializable for Statistic {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(Statistic {
|
Ok(Statistic {
|
||||||
name: try!(Serializable::read_from(buf)),
|
name: Serializable::read_from(buf)?,
|
||||||
value: try!(Serializable::read_from(buf)),
|
value: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.name.write_to(buf));
|
self.name.write_to(buf)?;
|
||||||
self.value.write_to(buf)
|
self.value.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -974,15 +974,15 @@ pub struct BlockChangeRecord {
|
||||||
impl Serializable for BlockChangeRecord {
|
impl Serializable for BlockChangeRecord {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(BlockChangeRecord {
|
Ok(BlockChangeRecord {
|
||||||
xz: try!(Serializable::read_from(buf)),
|
xz: Serializable::read_from(buf)?,
|
||||||
y: try!(Serializable::read_from(buf)),
|
y: Serializable::read_from(buf)?,
|
||||||
block_id: try!(Serializable::read_from(buf)),
|
block_id: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.xz.write_to(buf));
|
self.xz.write_to(buf)?;
|
||||||
try!(self.y.write_to(buf));
|
self.y.write_to(buf)?;
|
||||||
self.block_id.write_to(buf)
|
self.block_id.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -997,15 +997,15 @@ pub struct ExplosionRecord {
|
||||||
impl Serializable for ExplosionRecord {
|
impl Serializable for ExplosionRecord {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(ExplosionRecord {
|
Ok(ExplosionRecord {
|
||||||
x: try!(Serializable::read_from(buf)),
|
x: Serializable::read_from(buf)?,
|
||||||
y: try!(Serializable::read_from(buf)),
|
y: Serializable::read_from(buf)?,
|
||||||
z: try!(Serializable::read_from(buf)),
|
z: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.x.write_to(buf));
|
self.x.write_to(buf)?;
|
||||||
try!(self.y.write_to(buf));
|
self.y.write_to(buf)?;
|
||||||
self.z.write_to(buf)
|
self.z.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1020,15 +1020,15 @@ pub struct MapIcon {
|
||||||
impl Serializable for MapIcon {
|
impl Serializable for MapIcon {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(MapIcon {
|
Ok(MapIcon {
|
||||||
direction_type: try!(Serializable::read_from(buf)),
|
direction_type: Serializable::read_from(buf)?,
|
||||||
x: try!(Serializable::read_from(buf)),
|
x: Serializable::read_from(buf)?,
|
||||||
z: try!(Serializable::read_from(buf)),
|
z: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.direction_type.write_to(buf));
|
self.direction_type.write_to(buf)?;
|
||||||
try!(self.x.write_to(buf));
|
self.x.write_to(buf)?;
|
||||||
self.z.write_to(buf)
|
self.z.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1053,15 +1053,15 @@ pub struct EntityProperty {
|
||||||
impl Serializable for EntityProperty {
|
impl Serializable for EntityProperty {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(EntityProperty {
|
Ok(EntityProperty {
|
||||||
key: try!(Serializable::read_from(buf)),
|
key: Serializable::read_from(buf)?,
|
||||||
value: try!(Serializable::read_from(buf)),
|
value: Serializable::read_from(buf)?,
|
||||||
modifiers: try!(Serializable::read_from(buf)),
|
modifiers: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.key.write_to(buf));
|
self.key.write_to(buf)?;
|
||||||
try!(self.value.write_to(buf));
|
self.value.write_to(buf)?;
|
||||||
self.modifiers.write_to(buf)
|
self.modifiers.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1076,15 +1076,15 @@ pub struct PropertyModifier {
|
||||||
impl Serializable for PropertyModifier {
|
impl Serializable for PropertyModifier {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
Ok(PropertyModifier {
|
Ok(PropertyModifier {
|
||||||
uuid: try!(Serializable::read_from(buf)),
|
uuid: Serializable::read_from(buf)?,
|
||||||
amount: try!(Serializable::read_from(buf)),
|
amount: Serializable::read_from(buf)?,
|
||||||
operation: try!(Serializable::read_from(buf)),
|
operation: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
|
||||||
try!(self.uuid.write_to(buf));
|
self.uuid.write_to(buf)?;
|
||||||
try!(self.amount.write_to(buf));
|
self.amount.write_to(buf)?;
|
||||||
self.operation.write_to(buf)
|
self.operation.write_to(buf)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1098,25 +1098,25 @@ pub struct PlayerInfoData {
|
||||||
impl Serializable for PlayerInfoData {
|
impl Serializable for PlayerInfoData {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
|
||||||
let mut m = PlayerInfoData {
|
let mut m = PlayerInfoData {
|
||||||
action: try!(Serializable::read_from(buf)),
|
action: Serializable::read_from(buf)?,
|
||||||
players: Vec::new(),
|
players: Vec::new(),
|
||||||
};
|
};
|
||||||
let len = try!(VarInt::read_from(buf));
|
let len = VarInt::read_from(buf)?;
|
||||||
for _ in 0..len.0 {
|
for _ in 0..len.0 {
|
||||||
let uuid = try!(UUID::read_from(buf));
|
let uuid = UUID::read_from(buf)?;
|
||||||
match m.action.0 {
|
match m.action.0 {
|
||||||
0 => {
|
0 => {
|
||||||
let name = try!(String::read_from(buf));
|
let name = String::read_from(buf)?;
|
||||||
let mut props = Vec::new();
|
let mut props = Vec::new();
|
||||||
let plen = try!(VarInt::read_from(buf)).0;
|
let plen = VarInt::read_from(buf)?.0;
|
||||||
for _ in 0..plen {
|
for _ in 0..plen {
|
||||||
let mut prop = PlayerProperty {
|
let mut prop = PlayerProperty {
|
||||||
name: try!(String::read_from(buf)),
|
name: String::read_from(buf)?,
|
||||||
value: try!(String::read_from(buf)),
|
value: String::read_from(buf)?,
|
||||||
signature: Default::default(),
|
signature: Default::default(),
|
||||||
};
|
};
|
||||||
if try!(bool::read_from(buf)) {
|
if bool::read_from(buf)? {
|
||||||
prop.signature = Some(try!(String::read_from(buf)));
|
prop.signature = Some(String::read_from(buf)?);
|
||||||
}
|
}
|
||||||
props.push(prop);
|
props.push(prop);
|
||||||
}
|
}
|
||||||
|
@ -1124,11 +1124,11 @@ impl Serializable for PlayerInfoData {
|
||||||
uuid: uuid,
|
uuid: uuid,
|
||||||
name: name,
|
name: name,
|
||||||
properties: props,
|
properties: props,
|
||||||
gamemode: try!(Serializable::read_from(buf)),
|
gamemode: Serializable::read_from(buf)?,
|
||||||
ping: try!(Serializable::read_from(buf)),
|
ping: Serializable::read_from(buf)?,
|
||||||
display: {
|
display: {
|
||||||
if try!(bool::read_from(buf)) {
|
if bool::read_from(buf)? {
|
||||||
Some(try!(Serializable::read_from(buf)))
|
Some(Serializable::read_from(buf)?)
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
|
@ -1139,21 +1139,21 @@ impl Serializable for PlayerInfoData {
|
||||||
1 => {
|
1 => {
|
||||||
m.players.push(PlayerDetail::UpdateGamemode {
|
m.players.push(PlayerDetail::UpdateGamemode {
|
||||||
uuid: uuid,
|
uuid: uuid,
|
||||||
gamemode: try!(Serializable::read_from(buf)),
|
gamemode: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
2 => {
|
2 => {
|
||||||
m.players.push(PlayerDetail::UpdateLatency {
|
m.players.push(PlayerDetail::UpdateLatency {
|
||||||
uuid: uuid,
|
uuid: uuid,
|
||||||
ping: try!(Serializable::read_from(buf)),
|
ping: Serializable::read_from(buf)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
3 => {
|
3 => {
|
||||||
m.players.push(PlayerDetail::UpdateDisplayName {
|
m.players.push(PlayerDetail::UpdateDisplayName {
|
||||||
uuid: uuid,
|
uuid: uuid,
|
||||||
display: {
|
display: {
|
||||||
if try!(bool::read_from(buf)) {
|
if bool::read_from(buf)? {
|
||||||
Some(try!(Serializable::read_from(buf)))
|
Some(Serializable::read_from(buf)?)
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
|
|
|
@ -863,12 +863,12 @@ impl TextureManager {
|
||||||
use std::io::{Error, ErrorKind};
|
use std::io::{Error, ErrorKind};
|
||||||
let path = format!("skin-cache/{}/{}.png", &hash[..2], hash);
|
let path = format!("skin-cache/{}/{}.png", &hash[..2], hash);
|
||||||
let cache_path = Path::new(&path);
|
let cache_path = Path::new(&path);
|
||||||
try!(fs::create_dir_all(cache_path.parent().unwrap()));
|
fs::create_dir_all(cache_path.parent().unwrap())?;
|
||||||
let mut buf = vec![];
|
let mut buf = vec![];
|
||||||
if fs::metadata(cache_path).is_ok() {
|
if fs::metadata(cache_path).is_ok() {
|
||||||
// We have a cached image
|
// We have a cached image
|
||||||
let mut file = try!(fs::File::open(cache_path));
|
let mut file = fs::File::open(cache_path)?;
|
||||||
try!(file.read_to_end(&mut buf));
|
file.read_to_end(&mut buf)?;
|
||||||
} else {
|
} else {
|
||||||
// Need to download it
|
// Need to download it
|
||||||
let url = &format!("http://textures.minecraft.net/texture/{}", hash);
|
let url = &format!("http://textures.minecraft.net/texture/{}", hash);
|
||||||
|
@ -888,8 +888,8 @@ impl TextureManager {
|
||||||
}
|
}
|
||||||
|
|
||||||
// Save to cache
|
// Save to cache
|
||||||
let mut file = try!(fs::File::create(cache_path));
|
let mut file = fs::File::create(cache_path)?;
|
||||||
try!(file.write_all(&buf));
|
file.write_all(&buf)?;
|
||||||
}
|
}
|
||||||
let mut img = match image::load_from_memory(&buf) {
|
let mut img = match image::load_from_memory(&buf) {
|
||||||
Ok(val) => val,
|
Ok(val) => val,
|
||||||
|
|
|
@ -496,7 +496,7 @@ struct ProgressRead<'a, T> {
|
||||||
|
|
||||||
impl <'a, T: io::Read> io::Read for ProgressRead<'a, T> {
|
impl <'a, T: io::Read> io::Read for ProgressRead<'a, T> {
|
||||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
let size = try!(self.read.read(buf));
|
let size = self.read.read(buf)?;
|
||||||
Manager::add_task_progress(self.progress, &self.task_name, &self.task_file, size as u64);
|
Manager::add_task_progress(self.progress, &self.task_name, &self.task_file, size as u64);
|
||||||
Ok(size)
|
Ok(size)
|
||||||
}
|
}
|
||||||
|
|
|
@ -103,24 +103,24 @@ macro_rules! handle_packet {
|
||||||
impl Server {
|
impl Server {
|
||||||
|
|
||||||
pub fn connect(resources: Arc<RwLock<resources::Manager>>, profile: mojang::Profile, address: &str) -> Result<Server, protocol::Error> {
|
pub fn connect(resources: Arc<RwLock<resources::Manager>>, profile: mojang::Profile, address: &str) -> Result<Server, protocol::Error> {
|
||||||
let mut conn = try!(protocol::Conn::new(address));
|
let mut conn = protocol::Conn::new(address)?;
|
||||||
|
|
||||||
let host = conn.host.clone();
|
let host = conn.host.clone();
|
||||||
let port = conn.port;
|
let port = conn.port;
|
||||||
try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
|
conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
|
||||||
protocol_version: protocol::VarInt(protocol::SUPPORTED_PROTOCOL),
|
protocol_version: protocol::VarInt(protocol::SUPPORTED_PROTOCOL),
|
||||||
host: host,
|
host: host,
|
||||||
port: port,
|
port: port,
|
||||||
next: protocol::VarInt(2),
|
next: protocol::VarInt(2),
|
||||||
}));
|
})?;
|
||||||
conn.state = protocol::State::Login;
|
conn.state = protocol::State::Login;
|
||||||
try!(conn.write_packet(protocol::packet::login::serverbound::LoginStart {
|
conn.write_packet(protocol::packet::login::serverbound::LoginStart {
|
||||||
username: profile.username.clone(),
|
username: profile.username.clone(),
|
||||||
}));
|
})?;
|
||||||
|
|
||||||
let packet;
|
let packet;
|
||||||
loop {
|
loop {
|
||||||
match try!(conn.read_packet()) {
|
match conn.read_packet()? {
|
||||||
protocol::packet::Packet::SetInitialCompression(val) => {
|
protocol::packet::Packet::SetInitialCompression(val) => {
|
||||||
conn.set_compresssion(val.threshold.0);
|
conn.set_compresssion(val.threshold.0);
|
||||||
},
|
},
|
||||||
|
@ -156,12 +156,12 @@ impl Server {
|
||||||
println!("new shared_e({:}) = {:?}", shared_e.len(), &shared_e);
|
println!("new shared_e({:}) = {:?}", shared_e.len(), &shared_e);
|
||||||
println!("new token_e({:}) = {:?}", token_e.len(), &token_e);
|
println!("new token_e({:}) = {:?}", token_e.len(), &token_e);
|
||||||
|
|
||||||
try!(profile.join_server(&packet.server_id, &shared, &packet.public_key.data));
|
profile.join_server(&packet.server_id, &shared, &packet.public_key.data)?;
|
||||||
|
|
||||||
try!(conn.write_packet(protocol::packet::login::serverbound::EncryptionResponse {
|
conn.write_packet(protocol::packet::login::serverbound::EncryptionResponse {
|
||||||
shared_secret: protocol::LenPrefixedBytes::new(shared_e),
|
shared_secret: protocol::LenPrefixedBytes::new(shared_e),
|
||||||
verify_token: protocol::LenPrefixedBytes::new(token_e),
|
verify_token: protocol::LenPrefixedBytes::new(token_e),
|
||||||
}));
|
})?;
|
||||||
|
|
||||||
let mut read = conn.clone();
|
let mut read = conn.clone();
|
||||||
let mut write = conn.clone();
|
let mut write = conn.clone();
|
||||||
|
@ -171,7 +171,7 @@ impl Server {
|
||||||
|
|
||||||
let uuid;
|
let uuid;
|
||||||
loop {
|
loop {
|
||||||
match try!(read.read_packet()) {
|
match read.read_packet()? {
|
||||||
protocol::packet::Packet::SetInitialCompression(val) => {
|
protocol::packet::Packet::SetInitialCompression(val) => {
|
||||||
read.set_compresssion(val.threshold.0);
|
read.set_compresssion(val.threshold.0);
|
||||||
write.set_compresssion(val.threshold.0);
|
write.set_compresssion(val.threshold.0);
|
||||||
|
|
|
@ -64,40 +64,40 @@ impl Serializable for Metadata {
|
||||||
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, protocol::Error> {
|
fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, protocol::Error> {
|
||||||
let mut m = Metadata::new();
|
let mut m = Metadata::new();
|
||||||
loop {
|
loop {
|
||||||
let index = try!(u8::read_from(buf)) as i32;
|
let index = u8::read_from(buf)? as i32;
|
||||||
if index == 0xFF {
|
if index == 0xFF {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
let ty = try!(u8::read_from(buf));
|
let ty = u8::read_from(buf)?;
|
||||||
match ty {
|
match ty {
|
||||||
0 => m.put_raw(index, try!(i8::read_from(buf))),
|
0 => m.put_raw(index, i8::read_from(buf)?),
|
||||||
1 => m.put_raw(index, try!(protocol::VarInt::read_from(buf)).0),
|
1 => m.put_raw(index, protocol::VarInt::read_from(buf)?.0),
|
||||||
2 => m.put_raw(index, try!(f32::read_from(buf))),
|
2 => m.put_raw(index, f32::read_from(buf)?),
|
||||||
3 => m.put_raw(index, try!(String::read_from(buf))),
|
3 => m.put_raw(index, String::read_from(buf)?),
|
||||||
4 => m.put_raw(index, try!(format::Component::read_from(buf))),
|
4 => m.put_raw(index, format::Component::read_from(buf)?),
|
||||||
5 => m.put_raw(index, try!(Option::<item::Stack>::read_from(buf))),
|
5 => m.put_raw(index, Option::<item::Stack>::read_from(buf)?),
|
||||||
6 => m.put_raw(index, try!(bool::read_from(buf))),
|
6 => m.put_raw(index, bool::read_from(buf)?),
|
||||||
7 => m.put_raw(index,
|
7 => m.put_raw(index,
|
||||||
[try!(f32::read_from(buf)),
|
[f32::read_from(buf)?,
|
||||||
try!(f32::read_from(buf)),
|
f32::read_from(buf)?,
|
||||||
try!(f32::read_from(buf))]),
|
f32::read_from(buf)?]),
|
||||||
8 => m.put_raw(index, try!(Position::read_from(buf))),
|
8 => m.put_raw(index, Position::read_from(buf)?),
|
||||||
9 => {
|
9 => {
|
||||||
if try!(bool::read_from(buf)) {
|
if bool::read_from(buf)? {
|
||||||
m.put_raw(index, try!(Option::<Position>::read_from(buf)));
|
m.put_raw(index, Option::<Position>::read_from(buf)?);
|
||||||
} else {
|
} else {
|
||||||
m.put_raw::<Option<Position>>(index, None);
|
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 => {
|
11 => {
|
||||||
if try!(bool::read_from(buf)) {
|
if bool::read_from(buf)? {
|
||||||
m.put_raw(index, try!(Option::<protocol::UUID>::read_from(buf)));
|
m.put_raw(index, Option::<protocol::UUID>::read_from(buf)?);
|
||||||
} else {
|
} else {
|
||||||
m.put_raw::<Option<protocol::UUID>>(index, None);
|
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())),
|
_ => 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> {
|
fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
|
||||||
for (k, v) in &self.map {
|
for (k, v) in &self.map {
|
||||||
try!((*k as u8).write_to(buf));
|
(*k as u8).write_to(buf)?;
|
||||||
match *v {
|
match *v {
|
||||||
Value::Byte(ref val) => {
|
Value::Byte(ref val) => {
|
||||||
try!(u8::write_to(&0, buf));
|
u8::write_to(&0, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Int(ref val) => {
|
Value::Int(ref val) => {
|
||||||
try!(u8::write_to(&1, buf));
|
u8::write_to(&1, buf)?;
|
||||||
try!(protocol::VarInt(*val).write_to(buf));
|
protocol::VarInt(*val).write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Float(ref val) => {
|
Value::Float(ref val) => {
|
||||||
try!(u8::write_to(&2, buf));
|
u8::write_to(&2, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::String(ref val) => {
|
Value::String(ref val) => {
|
||||||
try!(u8::write_to(&3, buf));
|
u8::write_to(&3, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::FormatComponent(ref val) => {
|
Value::FormatComponent(ref val) => {
|
||||||
try!(u8::write_to(&4, buf));
|
u8::write_to(&4, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::OptionalItemStack(ref val) => {
|
Value::OptionalItemStack(ref val) => {
|
||||||
try!(u8::write_to(&5, buf));
|
u8::write_to(&5, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Bool(ref val) => {
|
Value::Bool(ref val) => {
|
||||||
try!(u8::write_to(&6, buf));
|
u8::write_to(&6, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Vector(ref val) => {
|
Value::Vector(ref val) => {
|
||||||
try!(u8::write_to(&7, buf));
|
u8::write_to(&7, buf)?;
|
||||||
try!(val[0].write_to(buf));
|
val[0].write_to(buf)?;
|
||||||
try!(val[1].write_to(buf));
|
val[1].write_to(buf)?;
|
||||||
try!(val[2].write_to(buf));
|
val[2].write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Position(ref val) => {
|
Value::Position(ref val) => {
|
||||||
try!(u8::write_to(&8, buf));
|
u8::write_to(&8, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::OptionalPosition(ref val) => {
|
Value::OptionalPosition(ref val) => {
|
||||||
try!(u8::write_to(&9, buf));
|
u8::write_to(&9, buf)?;
|
||||||
try!(val.is_some().write_to(buf));
|
val.is_some().write_to(buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Direction(ref val) => {
|
Value::Direction(ref val) => {
|
||||||
try!(u8::write_to(&10, buf));
|
u8::write_to(&10, buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::OptionalUUID(ref val) => {
|
Value::OptionalUUID(ref val) => {
|
||||||
try!(u8::write_to(&11, buf));
|
u8::write_to(&11, buf)?;
|
||||||
try!(val.is_some().write_to(buf));
|
val.is_some().write_to(buf)?;
|
||||||
try!(val.write_to(buf));
|
val.write_to(buf)?;
|
||||||
}
|
}
|
||||||
Value::Block(ref val) => {
|
Value::Block(ref val) => {
|
||||||
try!(u8::write_to(&11, buf));
|
u8::write_to(&11, buf)?;
|
||||||
try!(protocol::VarInt(*val as i32).write_to(buf));
|
protocol::VarInt(*val as i32).write_to(buf)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
try!(u8::write_to(&0xFF, buf));
|
u8::write_to(&0xFF, buf)?;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl fmt::Debug for Metadata {
|
impl fmt::Debug for Metadata {
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
try!(write!(f, "Metadata[ "));
|
write!(f, "Metadata[ ")?;
|
||||||
for (k, v) in &self.map {
|
for (k, v) in &self.map {
|
||||||
try!(write!(f, "{:?}={:?}, ", k, v));
|
write!(f, "{:?}={:?}, ", k, v)?;
|
||||||
}
|
}
|
||||||
write!(f, "]")
|
write!(f, "]")
|
||||||
}
|
}
|
||||||
|
|
|
@ -580,20 +580,20 @@ impl World {
|
||||||
let section = chunk.sections[i as usize].as_mut().unwrap();
|
let section = chunk.sections[i as usize].as_mut().unwrap();
|
||||||
section.dirty = true;
|
section.dirty = true;
|
||||||
|
|
||||||
let mut bit_size = try!(data.read_u8());
|
let mut bit_size = data.read_u8()?;
|
||||||
let mut mappings: HashMap<usize, block::Block, BuildHasherDefault<FNVHash>> = HashMap::with_hasher(BuildHasherDefault::default());
|
let mut mappings: HashMap<usize, block::Block, BuildHasherDefault<FNVHash>> = HashMap::with_hasher(BuildHasherDefault::default());
|
||||||
if bit_size == 0 {
|
if bit_size == 0 {
|
||||||
bit_size = 13;
|
bit_size = 13;
|
||||||
} else {
|
} else {
|
||||||
let count = try!(VarInt::read_from(&mut data)).0;
|
let count = VarInt::read_from(&mut data)?.0;
|
||||||
for i in 0 .. count {
|
for i in 0 .. count {
|
||||||
let id = try!(VarInt::read_from(&mut data)).0;
|
let id = VarInt::read_from(&mut data)?.0;
|
||||||
let bl = block::Block::by_vanilla_id(id as usize);
|
let bl = block::Block::by_vanilla_id(id as usize);
|
||||||
mappings.insert(i as usize, bl);
|
mappings.insert(i as usize, bl);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
let bits = try!(LenPrefixed::<VarInt, u64>::read_from(&mut data)).data;
|
let bits = LenPrefixed::<VarInt, u64>::read_from(&mut data)?.data;
|
||||||
let m = bit::Map::from_raw(bits, bit_size as usize);
|
let m = bit::Map::from_raw(bits, bit_size as usize);
|
||||||
|
|
||||||
for bi in 0 .. 4096 {
|
for bi in 0 .. 4096 {
|
||||||
|
@ -614,12 +614,12 @@ impl World {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
try!(data.read_exact(&mut section.block_light.data));
|
data.read_exact(&mut section.block_light.data)?;
|
||||||
try!(data.read_exact(&mut section.sky_light.data));
|
data.read_exact(&mut section.sky_light.data)?;
|
||||||
}
|
}
|
||||||
|
|
||||||
if new {
|
if new {
|
||||||
try!(data.read_exact(&mut chunk.biomes));
|
data.read_exact(&mut chunk.biomes)?;
|
||||||
}
|
}
|
||||||
|
|
||||||
chunk.calculate_heightmap();
|
chunk.calculate_heightmap();
|
||||||
|
|
Loading…
Reference in New Issue