mc-network-data-types 0.1.4

Minecraft network I/O data types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::io::{Read, Result, Write};

pub trait BoolRead {
    fn read_bool(&mut self) -> Result<bool>;
}

pub trait WriteBool {
    fn write_bool(&mut self, value: bool) -> Result<()>;
}

impl<R: Read> BoolRead for R {
    fn read_bool(&mut self) -> Result<bool> {
        let buf = &mut [0];
        self.read_exact(buf)?;
        Ok(unsafe { std::mem::transmute(buf[0]) })
    }
}

impl<W: Write> WriteBool for W {
    fn write_bool(&mut self, value: bool) -> Result<()> {
        self.write_all(&[value as u8])?;
        Ok(())
    }
}

pub trait U8Read {
    fn read_u8(&mut self) -> Result<u8>;
}

pub trait U8Write {
    fn write_u8(&mut self, value: u8) -> Result<()>;
}

impl<R: Read> U8Read for R {
    fn read_u8(&mut self) -> Result<u8> {
        let mut buf = [0u8];
        self.read_exact(&mut buf)?;
        Ok(buf[0])
    }
}

pub trait I8Read {
    fn read_i8(&mut self) -> Result<i8>;
}

impl<R: Read> I8Read for R {
    fn read_i8(&mut self) -> Result<i8> {
        let mut buf = [0];
        self.read_exact(&mut buf)?;
        Ok(buf[0] as i8)
    }
}

pub trait I8Write {
    fn write_i8(&mut self, value: i8) -> Result<()>;
}

impl<W: Write> I8Write for W {
    fn write_i8(&mut self, value: i8) -> Result<()> {
        self.write_all(&[value as u8])?;
        Ok(())
    }
}

impl<W: Write> U8Write for W {
    fn write_u8(&mut self, value: u8) -> Result<()> {
        self.write_all(&[value])?;
        Ok(())
    }
}

pub trait U16Read {
    fn read_u16(&mut self) -> Result<u16>;
}

impl<R: Read> U16Read for R {
    fn read_u16(&mut self) -> Result<u16> {
        let mut buf = [0; 2];
        self.read_exact(&mut buf)?;
        Ok(u16::from_be_bytes(buf))
    }
}

pub trait U16Write {
    fn write_u16(&mut self, value: u16) -> Result<()>;
}

impl<W: Write> U16Write for W {
    fn write_u16(&mut self, value: u16) -> Result<()> {
        self.write_all(&value.to_be_bytes())?;
        Ok(())
    }
}

pub trait I64Read {
    fn read_i64(&mut self) -> Result<i64>;
}

pub trait I64Write {
    fn write_i64(&mut self, value: i64) -> Result<()>;
}

impl<R: Read> I64Read for R {
    fn read_i64(&mut self) -> Result<i64> {
        let mut buf = [0; 8];
        self.read_exact(&mut buf)?;
        Ok(i64::from_be_bytes(buf))
    }
}

impl<W: Write> I64Write for W {
    fn write_i64(&mut self, value: i64) -> Result<()> {
        self.write_all(&value.to_be_bytes())?;
        Ok(())
    }
}

pub trait U128Read {
    fn read_u128(&mut self) -> Result<u128>;
}

pub trait U128Write {
    fn write_u128(&mut self, value: u128) -> Result<()>;
}

impl<R: Read> U128Read for R {
    fn read_u128(&mut self) -> Result<u128> {
        let mut buf = [0; 16];
        self.read_exact(&mut buf)?;
        Ok(u128::from_be_bytes(buf))
    }
}

impl<W: Write> U128Write for W {
    fn write_u128(&mut self, value: u128) -> Result<()> {
        self.write_all(&value.to_be_bytes())?;
        Ok(())
    }
}