remove atomic_clone feature

remove zigzag
add varint test
replace read_varint macro with size_varint
some rewrite varint reading

src/data/reader.rs

@@ -1,6 +1,5 @@
 use crate::{
-    data::varint::{read_varint, size_varint},
-    zigzag::Zigzag,
+    data::varint::read_varint,
     ProtocolError,
 };
 use std::io::Read;
@@ -25,174 +24,149 @@ pub trait DataReader {
     }
     /// Read Unsigned Short as u16
     fn read_unsigned_short(&mut self) -> Result<u16, ProtocolError> {
-        match self.read_bytes(2)?.try_into() {
-            Ok(i) => Ok(u16::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(2)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| u16::from_be_bytes(o))
     }
     /// Read Boolean
     fn read_boolean(&mut self) -> Result<bool, ProtocolError> {
-        Ok(self.read_byte()? == 0x01)
+        self.read_byte().map(|o| o == 0x01)
     }
     /// Read Short as i16
     fn read_short(&mut self) -> Result<i16, ProtocolError> {
-        match self.read_bytes(2)?.try_into() {
-            Ok(i) => Ok(i16::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(2)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| i16::from_be_bytes(o))
     }
     /// Read Long as i64
     fn read_long(&mut self) -> Result<i64, ProtocolError> {
-        match self.read_bytes(8)?.try_into() {
-            Ok(i) => Ok(i64::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(8)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| i64::from_be_bytes(o))
     }
     /// Read Float as f32
     fn read_float(&mut self) -> Result<f32, ProtocolError> {
-        match self.read_bytes(4)?.try_into() {
-            Ok(i) => Ok(f32::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(4)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| f32::from_be_bytes(o))
     }
     /// Read Double as f64
     fn read_double(&mut self) -> Result<f64, ProtocolError> {
-        match self.read_bytes(8)?.try_into() {
-            Ok(i) => Ok(f64::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(8)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| f64::from_be_bytes(o))
     }
     /// Read Int as i32
     fn read_int(&mut self) -> Result<i32, ProtocolError> {
-        match self.read_bytes(4)?.try_into() {
-            Ok(i) => Ok(i32::from_be_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(4)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| i32::from_be_bytes(o))
     }
     /// Read UUID
     fn read_uuid(&mut self) -> Result<Uuid, ProtocolError> {
-        match self.read_bytes(16)?.try_into() {
-            Ok(i) => Ok(Uuid::from_bytes(i)),
-            Err(_) => Err(ProtocolError::ReadError),
-        }
+        self.read_bytes(16)
+            .and_then(|o| o.try_into().map_err(|_| ProtocolError::ReadError))
+            .map(|o| Uuid::from_bytes(o))
     }
 
     /// Read VarInt as usize with size in bytes (varint, size)
     fn read_usize_varint_size(&mut self) -> Result<(usize, usize), ProtocolError> {
-        size_varint!(usize, self)
+        read_varint!(usize, self)
     }
     /// Read VarInt as u8 with size in bytes (varint, size)
     fn read_u8_varint_size(&mut self) -> Result<(u8, usize), ProtocolError> {
-        size_varint!(u8, self)
+        read_varint!(u8, self)
     }
     /// Read VarInt as u16 with size in bytes (varint, size)
     fn read_u16_varint_size(&mut self) -> Result<(u16, usize), ProtocolError> {
-        size_varint!(u16, self)
+        read_varint!(u16, self)
     }
     /// Read VarInt as u32 with size in bytes (varint, size)
     fn read_u32_varint_size(&mut self) -> Result<(u32, usize), ProtocolError> {
-        size_varint!(u32, self)
+        read_varint!(u32, self)
     }
     /// Read VarInt as u64 with size in bytes (varint, size)
     fn read_u64_varint_size(&mut self) -> Result<(u64, usize), ProtocolError> {
-        size_varint!(u64, self)
+        read_varint!(u64, self)
     }
     /// Read VarInt as u128 with size in bytes (varint, size)
     fn read_u128_varint_size(&mut self) -> Result<(u128, usize), ProtocolError> {
-        size_varint!(u128, self)
-    }
-
-    /// Read VarInt as isize with size in bytes (varint, size)
-    fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> {
-        Ok({
-            let i = self.read_usize_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
-    }
-    /// Read VarInt as i8 with size in bytes (varint, size)
-    fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> {
-        Ok({
-            let i = self.read_u8_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
-    }
-    /// Read VarInt as i16 with size in bytes (varint, size)
-    fn read_i16_varint_size(&mut self) -> Result<(i16, usize), ProtocolError> {
-        Ok({
-            let i = self.read_u16_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
-    }
-    /// Read VarInt as i32 with size in bytes (varint, size)
-    fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> {
-        Ok({
-            let i = self.read_u32_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
-    }
-    /// Read VarInt as i64 with size in bytes (varint, size)
-    fn read_i64_varint_size(&mut self) -> Result<(i64, usize), ProtocolError> {
-        Ok({
-            let i = self.read_u64_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
-    }
-    /// Read VarInt as i128 with size in bytes (varint, size)
-    fn read_i128_varint_size(&mut self) -> Result<(i128, usize), ProtocolError> {
-        Ok({
-            let i = self.read_u128_varint_size()?;
-            (i.0.zigzag(), i.1)
-        })
+        read_varint!(u128, self)
     }
 
     /// Read VarInt as usize
     fn read_usize_varint(&mut self) -> Result<usize, ProtocolError> {
-        read_varint!(usize, self)
+        self.read_usize_varint_size().map(|o| o.0)
     }
     /// Read VarInt as u8
     fn read_u8_varint(&mut self) -> Result<u8, ProtocolError> {
-        read_varint!(u8, self)
+        self.read_u8_varint_size().map(|o| o.0)
     }
     /// Read VarInt as u16
     fn read_u16_varint(&mut self) -> Result<u16, ProtocolError> {
-        read_varint!(u16, self)
+        self.read_u16_varint_size().map(|o| o.0)
     }
     /// Read VarInt as u32
     fn read_u32_varint(&mut self) -> Result<u32, ProtocolError> {
-        read_varint!(u32, self)
+        self.read_u32_varint_size().map(|o| o.0)
     }
     /// Read VarInt as u64
     fn read_u64_varint(&mut self) -> Result<u64, ProtocolError> {
-        read_varint!(u64, self)
+        self.read_u64_varint_size().map(|o| o.0)
     }
     /// Read VarInt as u128
     fn read_u128_varint(&mut self) -> Result<u128, ProtocolError> {
-        read_varint!(u128, self)
+        self.read_u128_varint_size().map(|o| o.0)
     }
 
-    /// Read VarInt as isize
+    /// Read VarInt as usize with zigzag
     fn read_isize_varint(&mut self) -> Result<isize, ProtocolError> {
-        Ok(self.read_usize_varint()?.zigzag())
+        self.read_usize_varint().map(|o| o as isize)
     }
-    /// Read VarInt as i8
+    /// Read VarInt as u8 with zigzag
     fn read_i8_varint(&mut self) -> Result<i8, ProtocolError> {
-        Ok(self.read_u8_varint()?.zigzag())
+        self.read_u8_varint().map(|o| o as i8)
     }
-    /// Read VarInt as i16
+    /// Read VarInt as u16 with zigzag
     fn read_i16_varint(&mut self) -> Result<i16, ProtocolError> {
-        Ok(self.read_u16_varint()?.zigzag())
+        self.read_u16_varint().map(|o| o as i16)
     }
-    /// Read VarInt as i32
+    /// Read VarInt as u32 with zigzag
     fn read_i32_varint(&mut self) -> Result<i32, ProtocolError> {
-        Ok(self.read_u32_varint()?.zigzag())
+        self.read_u32_varint().map(|o| o as i32)
     }
-    /// Read VarInt as i64
+    /// Read VarInt as u64 with zigzag
     fn read_i64_varint(&mut self) -> Result<i64, ProtocolError> {
-        Ok(self.read_u64_varint()?.zigzag())
+        self.read_u64_varint().map(|o| o as i64)
     }
-    /// Read VarInt as i128
+    /// Read VarInt as u128 with zigzag
     fn read_i128_varint(&mut self) -> Result<i128, ProtocolError> {
-        Ok(self.read_u128_varint()?.zigzag())
+        self.read_u128_varint().map(|o| o as i128)
+    }
+
+    /// Read VarInt as usize with zigzag with size in bytes (varint, size)
+    fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> {
+        self.read_usize_varint_size().map(|o| (o.0 as isize, o.1))
+    }
+    /// Read VarInt as u8 with zigzag with size in bytes (varint, size)
+    fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> {
+        self.read_u8_varint_size().map(|o| (o.0 as i8, o.1))
+    }
+    /// Read VarInt as u16 with zigzag with size in bytes (varint, size)
+    fn read_i16_varint_size(&mut self) -> Result<(i16, usize), ProtocolError> {
+        self.read_u16_varint_size().map(|o| (o.0 as i16, o.1))
+    }
+    /// Read VarInt as u32 with zigzag with size in bytes (varint, size)
+    fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> {
+        self.read_u32_varint_size().map(|o| (o.0 as i32, o.1))
+    }
+    /// Read VarInt as u64 with zigzag with size in bytes (varint, size)
+    fn read_i64_varint_size(&mut self) -> Result<(i64, usize), ProtocolError> {
+        self.read_u64_varint_size().map(|o| (o.0 as i64, o.1))
+    }
+    /// Read VarInt as u128 with zigzag with size in bytes (varint, size)
+    fn read_i128_varint_size(&mut self) -> Result<(i128, usize), ProtocolError> {
+        self.read_u128_varint_size().map(|o| (o.0 as i128, o.1))
     }
 }
 

src/data/varint.rs

@@ -1,4 +1,4 @@
-macro_rules! size_varint {
+macro_rules! read_varint {
     ($type:ty, $self:expr) => {{
         let mut shift: $type = 0;
         let mut decoded: $type = 0;
@@ -12,9 +12,9 @@ macro_rules! size_varint {
                 return Err(ProtocolError::VarIntError);
             }
 
-            decoded |= ((next & 0b01111111) as $type) << shift;
+            decoded |= ((next & 0x7F) as $type) << shift;
 
-            if next & 0b10000000 == 0b10000000 {
+            if next & 0x80 == 0x80 {
                 shift += 7;
             } else {
                 return Ok((decoded, size));
@@ -23,29 +23,6 @@ macro_rules! size_varint {
     }};
 }
 
-macro_rules! read_varint {
-    ($type:ty, $self:expr) => {{
-        let mut shift: $type = 0;
-        let mut decoded: $type = 0;
-
-        loop {
-            let next = DataReader::read_byte($self)?;
-
-            if shift >= (std::mem::size_of::<$type>() * 8) as $type {
-                return Err(ProtocolError::VarIntError);
-            }
-
-            decoded |= ((next & 0b01111111) as $type) << shift;
-
-            if next & 0b10000000 == 0b10000000 {
-                shift += 7;
-            } else {
-                return Ok(decoded);
-            }
-        }
-    }};
-}
-
 macro_rules! write_varint {
     ($type:ty, $self:expr, $value:expr) => {{
         let mut value: $type = $value;
@@ -53,18 +30,15 @@ macro_rules! write_varint {
         if value == 0 {
             DataWriter::write_byte($self, 0)
         } else {
-            while value >= 0b10000000 {
-                let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
+            while value >= 0x80 {
+                DataWriter::write_byte($self, ((value & 0x7F) as u8) | 0x80)?;
                 value >>= 7;
-
-                DataWriter::write_byte($self, next)?;
             }
 
-            DataWriter::write_byte($self, (value & 0b01111111) as u8)
+            DataWriter::write_byte($self, (value & 0x7F) as u8)
         }
     }};
 }
 
 pub(crate) use read_varint;
-pub(crate) use size_varint;
 pub(crate) use write_varint;

src/data/writer.rs

@@ -1,4 +1,4 @@
-use crate::{data::varint::write_varint, zigzag::Zigzag, ProtocolError};
+use crate::{data::varint::write_varint, ProtocolError};
 use std::io::Write;
 use uuid::Uuid;
 
@@ -23,52 +23,31 @@ pub trait DataWriter {
     }
     /// Write Unsigned Short as u16
     fn write_unsigned_short(&mut self, val: u16) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
     /// Write Boolean
     fn write_boolean(&mut self, val: bool) -> Result<(), ProtocolError> {
-        match self.write_byte(if val { 0x01 } else { 0x00 }) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_byte(if val { 0x01 } else { 0x00 })
     }
     /// Write Short as i16
     fn write_short(&mut self, val: i16) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
     /// Write Long as i64
     fn write_long(&mut self, val: i64) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
     /// Write Float as f32
     fn write_float(&mut self, val: f32) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
     /// Write Double as f64
     fn write_double(&mut self, val: f64) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
     /// Write Int as i32
     fn write_int(&mut self, val: i32) -> Result<(), ProtocolError> {
-        match self.write_bytes(&val.to_be_bytes()) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(ProtocolError::UnsignedShortError),
-        }
+        self.write_bytes(&val.to_be_bytes())
     }
 
     /// Write VarInt as usize
@@ -98,27 +77,27 @@ pub trait DataWriter {
 
     /// Write VarInt as isize
     fn write_isize_varint(&mut self, val: isize) -> Result<(), ProtocolError> {
-        self.write_usize_varint(val.zigzag())
+        self.write_usize_varint(val as usize)
     }
     /// Write VarInt as i8
     fn write_i8_varint(&mut self, val: i8) -> Result<(), ProtocolError> {
-        self.write_u8_varint(val.zigzag())
+        self.write_u8_varint(val as u8)
     }
     /// Write VarInt as i16
     fn write_i16_varint(&mut self, val: i16) -> Result<(), ProtocolError> {
-        self.write_u16_varint(val.zigzag())
+        self.write_u16_varint(val as u16)
     }
     /// Write VarInt as i32
     fn write_i32_varint(&mut self, val: i32) -> Result<(), ProtocolError> {
-        self.write_u32_varint(val.zigzag())
+        self.write_u32_varint(val as u32)
     }
     /// Write VarInt as i64
     fn write_i64_varint(&mut self, val: i64) -> Result<(), ProtocolError> {
-        self.write_u64_varint(val.zigzag())
+        self.write_u64_varint(val as u64)
     }
     /// Write VarInt as i128
     fn write_i128_varint(&mut self, val: i128) -> Result<(), ProtocolError> {
-        self.write_u128_varint(val.zigzag())
+        self.write_u128_varint(val as u128)
     }
 }