cubic_protocol/
packet.rs

1use quick_error::quick_error;
2
3quick_error! {
4    #[derive(Debug)]
5    pub enum CustomError {
6        Error(err: Box<dyn std::error::Error + Send + Sync>) {
7            display("{}", err)
8            from()
9            source(&**err)
10        }
11        String(message: String) {
12            display("{}", message)
13        }
14        StaticStr(message: &'static str) {
15            display("{}", message)
16        }
17    }
18}
19
20quick_error! {
21    #[derive(Debug)]
22    pub enum InputPacketBytesError {
23        NoBytes(length: usize) {
24            display("Length of the packet is {}", length)
25        }
26        Custom(err: CustomError) {
27            display("Input packet caused an error {}", err)
28            from()
29            source(err)
30        }
31    }
32}
33
34quick_error! {
35    #[derive(Debug)]
36    pub enum PacketReadableError {
37        InputPacketBytes(err: InputPacketBytesError) {
38            display("{}", err)
39            from()
40            source(err)
41        }
42        Custom(err: CustomError) {
43            display("Readable caused an error {}", err)
44            from()
45            source(err)
46        }
47    }
48}
49
50quick_error! {
51    #[derive(Debug)]
52    pub enum PacketWritableError {
53        Custom(err: CustomError) {
54            display("Writable caused an error {}", err)
55            from()
56            source(err)
57        }
58    }
59}
60
61pub type InputPacketBytesResult<T> = std::result::Result<T, InputPacketBytesError>;
62pub type OutputPacketBytesResult = std::result::Result<(), Box<dyn std::error::Error + Send + Sync>>;
63pub type PacketWritableResult = std::result::Result<(), PacketWritableError>;
64pub type PacketReadableResult<T> = std::result::Result<T, PacketReadableError>;
65
66#[async_trait::async_trait]
67pub trait InputPacketBytes: Send + Sync {
68    async fn take_byte(&mut self) -> InputPacketBytesResult<u8>;
69
70    async fn take_slice(&mut self, slice: &mut [u8]) -> InputPacketBytesResult<()>;
71
72    async fn take_vec(&mut self, vec: &mut Vec<u8>, count: usize) -> InputPacketBytesResult<()>;
73
74    fn has_bytes(&self, count: usize) -> bool;
75
76    fn remaining_bytes(&self) -> usize;
77}
78
79#[async_trait::async_trait]
80pub trait OutputPacketBytes: Send + Sync {
81    async fn write_byte(&mut self, byte: u8) -> OutputPacketBytesResult;
82
83    async fn write_bytes(&mut self, slice: &[u8]) -> OutputPacketBytesResult;
84}
85
86#[async_trait::async_trait]
87pub trait PacketWritable {
88    async fn write(self, output: &mut impl OutputPacketBytes) -> PacketWritableResult;
89}
90
91#[async_trait::async_trait]
92pub trait PacketReadable: Sized {
93    async fn read(input: &mut impl InputPacketBytes) -> PacketReadableResult<Self>;
94}
95
96#[derive(Debug, Copy, Clone, PartialEq)]
97pub enum PacketState {
98    Handshake,
99    Status,
100    Login,
101    Play,
102}
103
104#[derive(Debug, Copy, Clone, PartialEq)]
105pub enum PacketSide {
106    Server,
107    Client,
108}
109
110pub trait Packet: PacketWritable + PacketReadable {
111    fn id() -> i32;
112
113    fn side() -> PacketSide;
114
115    fn state() -> PacketState;
116
117    fn protocol() -> i32;
118}
cubic_protocol/packet.rs

cubic_protocol/
packet.rs
