remove bytebuffer

Cargo.toml

@@ -12,7 +12,6 @@ edition = "2021"
 
 [dependencies]
 flate2 = "1.0.35"
-bytebuffer = "2.3.0"
 uuid = "1.11.0"
 
 [features]

examples/recv_motd.rs

@@ -1,4 +1,4 @@
-use rust_mc_proto::{Packet, ProtocolError, MCConnTcp, DataBufferReader, DataBufferWriter};
+use rust_mc_proto::{Packet, ProtocolError, MCConnTcp, DataReader, DataWriter};
 
 /*
 

examples/recv_motd_dirty.rs

@@ -1,4 +1,4 @@
-use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, Packet, ProtocolError};
+use rust_mc_proto::{DataReader, DataWriter, MCConnTcp, Packet, ProtocolError};
 
 fn main() -> Result<(), ProtocolError> {
     let mut conn = MCConnTcp::connect("localhost:25565")?; // connecting

examples/status_server.rs

@@ -1,5 +1,5 @@
 use std::{net::TcpListener, sync::Arc, thread};
-use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, MinecraftConnection, Packet, ProtocolError};
+use rust_mc_proto::{DataReader, DataWriter, MCConnTcp, MinecraftConnection, Packet, ProtocolError};
 
 /*
 

src/data/reader.rs

@@ -1,14 +1,13 @@
 use crate::{
-    data_buffer::varint::{read_varint, size_varint},
+    data::varint::{read_varint, size_varint},
     zigzag::Zigzag,
     ProtocolError,
 };
-use bytebuffer::ByteBuffer;
 use std::io::Read;
 use uuid::Uuid;
 
 /// Packet data reader trait
-pub trait DataBufferReader {
+pub trait DataReader {
     /// Read bytes
     fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError>;
 
@@ -16,10 +15,6 @@ pub trait DataBufferReader {
     fn read_byte(&mut self) -> Result<u8, ProtocolError> {
         Ok(self.read_bytes(1)?[0])
     }
-    /// Read [`ByteBuffer`](ByteBuffer)
-    fn read_buffer(&mut self, size: usize) -> Result<ByteBuffer, ProtocolError> {
-        Ok(ByteBuffer::from_vec(self.read_bytes(size)?))
-    }
     /// Read String
     fn read_string(&mut self) -> Result<String, ProtocolError> {
         let size = self.read_usize_varint()?;
@@ -201,7 +196,7 @@ pub trait DataBufferReader {
     }
 }
 
-impl<R: Read> DataBufferReader for R {
+impl<R: Read> DataReader for R {
     fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError> {
         let mut buf = vec![0; size];
         match self.read(&mut buf) {

src/data/varint.rs

@@ -5,7 +5,7 @@ macro_rules! size_varint {
         let mut size: usize = 0;
 
         loop {
-            let next = DataBufferReader::read_byte($self)?;
+            let next = DataReader::read_byte($self)?;
             size += 1;
 
             if shift >= (std::mem::size_of::<$type>() * 8) as $type {
@@ -29,7 +29,7 @@ macro_rules! read_varint {
         let mut decoded: $type = 0;
 
         loop {
-            let next = DataBufferReader::read_byte($self)?;
+            let next = DataReader::read_byte($self)?;
 
             if shift >= (std::mem::size_of::<$type>() * 8) as $type {
                 return Err(ProtocolError::VarIntError);
@@ -51,16 +51,16 @@ macro_rules! write_varint {
         let mut value: $type = $value;
 
         if value == 0 {
-            DataBufferWriter::write_byte($self, 0)
+            DataWriter::write_byte($self, 0)
         } else {
             while value >= 0b10000000 {
                 let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
                 value >>= 7;
 
-                DataBufferWriter::write_byte($self, next)?;
+                DataWriter::write_byte($self, next)?;
             }
 
-            DataBufferWriter::write_byte($self, (value & 0b01111111) as u8)
+            DataWriter::write_byte($self, (value & 0b01111111) as u8)
         }
     }};
 }

src/data/writer.rs

@@ -1,10 +1,9 @@
-use crate::{data_buffer::varint::write_varint, zigzag::Zigzag, ProtocolError};
-use bytebuffer::ByteBuffer;
+use crate::{data::varint::write_varint, zigzag::Zigzag, ProtocolError};
 use std::io::Write;
 use uuid::Uuid;
 
 /// Packet data writer trait
-pub trait DataBufferWriter {
+pub trait DataWriter {
     /// Write bytes
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError>;
 
@@ -12,10 +11,6 @@ pub trait DataBufferWriter {
     fn write_byte(&mut self, byte: u8) -> Result<(), ProtocolError> {
         self.write_bytes(&[byte])
     }
-    /// Write [`ByteBuffer`](ByteBuffer)
-    fn write_buffer(&mut self, buffer: &ByteBuffer) -> Result<(), ProtocolError> {
-        self.write_bytes(buffer.as_bytes())
-    }
     /// Write String
     fn write_string(&mut self, val: &str) -> Result<(), ProtocolError> {
         let bytes = val.as_bytes();
@@ -127,7 +122,7 @@ pub trait DataBufferWriter {
     }
 }
 
-impl<W: Write> DataBufferWriter for W {
+impl<W: Write> DataWriter for W {
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError> {
         match self.write_all(bytes) {
             Ok(_) => Ok(()),

src/lib.rs

@@ -1,16 +1,15 @@
 #[cfg(test)]
 mod tests;
 
-pub mod data_buffer;
+pub mod data;
 pub mod packet;
 pub mod zigzag;
 
 pub use crate::{
-    data_buffer::{DataBufferReader, DataBufferWriter},
+    data::{DataReader, DataWriter},
     packet::Packet,
 };
 
-use bytebuffer::ByteBuffer;
 use flate2::{read::ZlibDecoder, write::ZlibEncoder, Compression};
 use std::{
     error::Error, fmt, io::{Read, Write}, net::{TcpStream, ToSocketAddrs}, sync::atomic::AtomicBool, usize
@@ -118,7 +117,7 @@ impl MinecraftConnection<TcpStream> {
     }
 }
 
-impl<T: Read + Write> DataBufferReader for MinecraftConnection<T> {
+impl<T: Read + Write> DataReader for MinecraftConnection<T> {
     fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError> {
         let mut buf = vec![0; size];
         match self.stream.read_exact(&mut buf) {
@@ -128,7 +127,7 @@ impl<T: Read + Write> DataBufferReader for MinecraftConnection<T> {
     }
 }
 
-impl<T: Read + Write> DataBufferWriter for MinecraftConnection<T> {
+impl<T: Read + Write> DataWriter for MinecraftConnection<T> {
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError> {
         match self.stream.write_all(bytes) {
             Ok(_) => Ok(()),
@@ -373,34 +372,34 @@ pub fn write_packet<T: Write>(
     compression_type: u32,
     packet: &Packet,
 ) -> Result<(), ProtocolError> {
-    let mut buf = ByteBuffer::new();
+    let mut buf = Vec::new();
 
-    let mut data_buf = ByteBuffer::new();
+    let mut data_buf = Vec::new();
     data_buf.write_u8_varint(packet.id())?;
-    data_buf.write_buffer(packet.buffer())?;
+    data_buf.write_bytes(packet.get_bytes())?;
 
     if let Some(compression) = compression {
-        let mut packet_buf = ByteBuffer::new();
+        let mut packet_buf = Vec::new();
 
         if data_buf.len() >= compression {
-            let compressed_data = compress_zlib(data_buf.as_bytes(), compression_type)?;
+            let compressed_data = compress_zlib(&data_buf, compression_type)?;
             packet_buf.write_usize_varint(data_buf.len())?;
             packet_buf
                 .write_all(&compressed_data)
                 .or(Err(ProtocolError::WriteError))?;
         } else {
             packet_buf.write_usize_varint(0)?;
-            packet_buf.write_buffer(&data_buf)?;
+            packet_buf.write_bytes(&data_buf)?;
         }
 
         buf.write_usize_varint(packet_buf.len())?;
-        buf.write_buffer(&packet_buf)?;
+        buf.write_bytes(&packet_buf)?;
     } else {
         buf.write_usize_varint(data_buf.len())?;
-        buf.write_buffer(&data_buf)?;
+        buf.write_bytes(&data_buf)?;
     }
 
-    stream.write_buffer(&buf)?;
+    stream.write_bytes(&buf)?;
 
     Ok(())
 }

src/packet.rs

@@ -1,32 +1,31 @@
-use crate::data_buffer::{DataBufferReader, DataBufferWriter};
+use crate::data::{DataReader, DataWriter};
 use crate::ProtocolError;
-use bytebuffer::ByteBuffer;
-use std::io::{Read, Write};
+use std::io::Cursor;
 
 /// Minecraft packet
 #[derive(Debug, Clone)]
 pub struct Packet {
     id: u8,
-    buffer: ByteBuffer,
+    cursor: Cursor<Vec<u8>>,
 }
 
 impl Packet {
     /// Create new packet from id and buffer
-    pub fn new(id: u8, buffer: ByteBuffer) -> Packet {
-        Packet { id, buffer }
+    pub fn new(id: u8, cursor: Cursor<Vec<u8>>) -> Packet {
+        Packet { id, cursor }
     }
 
-    /// Create new packet from packet data
+    /// Create new packet from raw packet (id + data)
     pub fn from_data(data: &[u8]) -> Result<Packet, ProtocolError> {
-        let mut buf = ByteBuffer::from_bytes(data);
+        let mut cursor = Cursor::new(data);
 
-        let (packet_id, packet_id_size) = buf.read_u8_varint_size()?;
+        let (packet_id, packet_id_size) = cursor.read_u8_varint_size()?;
         let packet_data =
-            DataBufferReader::read_bytes(&mut buf, data.len() - packet_id_size as usize)?;
+            DataReader::read_bytes(&mut cursor, data.len() - packet_id_size as usize)?;
 
         Ok(Packet {
             id: packet_id,
-            buffer: ByteBuffer::from_bytes(&packet_data),
+            cursor: Cursor::new(packet_data),
         })
     }
 
@@ -34,7 +33,7 @@ impl Packet {
     pub fn from_bytes(id: u8, data: &[u8]) -> Packet {
         Packet {
             id,
-            buffer: ByteBuffer::from_bytes(data),
+            cursor: Cursor::new(data.to_vec()),
         }
     }
 
@@ -42,7 +41,7 @@ impl Packet {
     pub fn empty(id: u8) -> Packet {
         Packet {
             id,
-            buffer: ByteBuffer::new(),
+            cursor: Cursor::new(Vec::new()),
         }
     }
 
@@ -66,52 +65,56 @@ impl Packet {
         self.id = id;
     }
 
-    /// Get mutable reference of buffer
-    pub fn buffer_mut(&mut self) -> &mut ByteBuffer {
-        &mut self.buffer
+    /// Set packet cursor
+    pub fn set_cursor(&mut self, cursor: Cursor<Vec<u8>>) {
+        self.cursor = cursor;
     }
 
-    /// Get immutable reference of buffer
-    pub fn buffer(&self) -> &ByteBuffer {
-        &self.buffer
-    }
-
-    /// Set packet buffer
-    pub fn set_buffer(&mut self, buffer: ByteBuffer) {
-        self.buffer = buffer;
-    }
-
-    /// Get buffer length
+    /// Get cursor length
     pub fn len(&self) -> usize {
-        self.buffer.len()
+        self.cursor.get_ref().len() - self.cursor.position() as usize
     }
 
-    /// Is buffer empty
+    /// Is cursor empty
     pub fn is_empty(&self) -> bool {
-        self.buffer.len() == 0
+        self.len() == 0
     }
 
-    /// Get buffer bytes
-    pub fn get_bytes(&self) -> Vec<u8> {
-        self.buffer.as_bytes().to_vec()
+    /// Get cursor remaining bytes
+    pub fn get_bytes(&self) -> &[u8] {
+        &self.cursor.get_ref()
+    }
+
+    /// Get mutable reference to cursor
+    pub fn get_mut(&mut self) -> &mut Cursor<Vec<u8>> {
+        &mut self.cursor
+    }
+
+    /// Get immutable reference to cursor
+    pub fn get_ref(&self) -> &Cursor<Vec<u8>> {
+        &self.cursor
+    }
+
+    /// Get inner cursor
+    pub fn into_inner(self) -> Cursor<Vec<u8>> {
+        self.cursor
     }
 }
 
-impl DataBufferReader for Packet {
+impl Into<Cursor<Vec<u8>>> for Packet {
+    fn into(self) -> Cursor<Vec<u8>> {
+        self.cursor
+    }
+}
+
+impl DataReader for Packet {
     fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError> {
-        let mut buf = vec![0; size];
-        match self.buffer.read_exact(&mut buf) {
-            Ok(_) => Ok(buf),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.cursor.read_bytes(size)
     }
 }
 
-impl DataBufferWriter for Packet {
+impl DataWriter for Packet {
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError> {
-        match self.buffer.write_all(bytes) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::WriteError),
-        }
+        self.cursor.write_bytes(bytes)
     }
 }

src/tests.rs

@@ -1,7 +1,7 @@
 use uuid::Uuid;
 
 use super::*;
-use std::{net::TcpListener, thread};
+use std::{io::Cursor, net::TcpListener, thread};
 
 #[test]
 fn test_data_transfer() -> Result<(), ProtocolError> {
@@ -134,13 +134,16 @@ fn test_data_transfer() -> Result<(), ProtocolError> {
 
 #[test]
 fn test_compression() -> Result<(), ProtocolError> {
-    let mut conn = MCConn::new(ByteBuffer::new());
+    let mut conn = MCConn::new(Cursor::new(Vec::new()));
     conn.set_compression(Some(5));
 
     let mut packet_1 = Packet::empty(0x12);
     packet_1.write_bytes(b"1234567890qwertyuiopasdfghjklzxcvbnm")?;
+    dbg!(&packet_1);
     conn.write_packet(&packet_1)?;
 
+    conn.get_mut().set_position(0);
+
     let mut packet_2 = conn.read_packet()?;
 
     assert_eq!(