From ca353b98828b88915b0f145b65db1469b6a43cba Mon Sep 17 00:00:00 2001
From: Victor Koenders <gpg@trangar.com>
Date: Sun, 19 Sep 2021 10:53:07 +0200
Subject: [PATCH] Added decode_unsigned

---
 src/varint/decode_unsigned.rs | 288 ++++++++++++++++++++++++++++++++++
 src/varint/mod.rs             |   5 +
 2 files changed, 293 insertions(+)
 create mode 100644 src/varint/decode_unsigned.rs

diff --git a/src/varint/decode_unsigned.rs b/src/varint/decode_unsigned.rs
new file mode 100644
index 0000000..fcb7379
--- /dev/null
+++ b/src/varint/decode_unsigned.rs
@@ -0,0 +1,288 @@
+use super::{U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
+use crate::{
+    config::Endian,
+    de::read::Reader,
+    error::{DecodeError, IntegerType},
+};
+
+#[allow(dead_code)]
+pub fn varint_decode_u16<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<u16, DecodeError> {
+    let mut byte = [0u8; 1];
+    read.read(&mut byte)?;
+    match byte[0] {
+        U16_BYTE => {
+            let mut bytes = [0u8; 2];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u16::from_be_bytes(bytes),
+                Endian::Little => u16::from_le_bytes(bytes),
+            })
+        }
+        U32_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U16,
+            found: IntegerType::U32,
+        }),
+        U64_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U16,
+            found: IntegerType::U64,
+        }),
+        U128_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U16,
+            found: IntegerType::U128,
+        }),
+        x => Ok(x as u16),
+    }
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_u32<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<u32, DecodeError> {
+    let mut byte = [0u8; 1];
+    read.read(&mut byte)?;
+    match byte[0] {
+        U16_BYTE => {
+            let mut bytes = [0u8; 2];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u16::from_be_bytes(bytes) as u32,
+                Endian::Little => u16::from_le_bytes(bytes) as u32,
+            })
+        }
+        U32_BYTE => {
+            let mut bytes = [0u8; 4];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u32::from_be_bytes(bytes),
+                Endian::Little => u32::from_le_bytes(bytes),
+            })
+        }
+        U64_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U32,
+            found: IntegerType::U64,
+        }),
+        U128_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U32,
+            found: IntegerType::U128,
+        }),
+        x => Ok(x as u32),
+    }
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_u64<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<u64, DecodeError> {
+    let mut byte = [0u8; 1];
+    read.read(&mut byte)?;
+    match byte[0] {
+        U16_BYTE => {
+            let mut bytes = [0u8; 2];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u16::from_be_bytes(bytes) as u64,
+                Endian::Little => u16::from_le_bytes(bytes) as u64,
+            })
+        }
+        U32_BYTE => {
+            let mut bytes = [0u8; 4];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u32::from_be_bytes(bytes) as u64,
+                Endian::Little => u32::from_le_bytes(bytes) as u64,
+            })
+        }
+        U64_BYTE => {
+            let mut bytes = [0u8; 8];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u64::from_be_bytes(bytes),
+                Endian::Little => u64::from_le_bytes(bytes),
+            })
+        }
+        U128_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::U64,
+            found: IntegerType::U128,
+        }),
+        x => Ok(x as u64),
+    }
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_usize<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<usize, DecodeError> {
+    let mut byte = [0u8; 1];
+    read.read(&mut byte)?;
+    match byte[0] {
+        U16_BYTE => {
+            let mut bytes = [0u8; 2];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u16::from_be_bytes(bytes) as usize,
+                Endian::Little => u16::from_le_bytes(bytes) as usize,
+            })
+        }
+        U32_BYTE => {
+            let mut bytes = [0u8; 4];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u32::from_be_bytes(bytes) as usize,
+                Endian::Little => u32::from_le_bytes(bytes) as usize,
+            })
+        }
+        U64_BYTE => {
+            let mut bytes = [0u8; 8];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u64::from_be_bytes(bytes) as usize,
+                Endian::Little => u64::from_le_bytes(bytes) as usize,
+            })
+        }
+        U128_BYTE => Err(DecodeError::InvalidIntegerType {
+            expected: IntegerType::USize,
+            found: IntegerType::U128,
+        }),
+        x => Ok(x as usize),
+    }
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_u128<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<u128, DecodeError> {
+    let mut byte = [0u8; 1];
+    read.read(&mut byte)?;
+    match byte[0] {
+        U16_BYTE => {
+            let mut bytes = [0u8; 2];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u16::from_be_bytes(bytes) as u128,
+                Endian::Little => u16::from_le_bytes(bytes) as u128,
+            })
+        }
+        U32_BYTE => {
+            let mut bytes = [0u8; 4];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u32::from_be_bytes(bytes) as u128,
+                Endian::Little => u32::from_le_bytes(bytes) as u128,
+            })
+        }
+        U64_BYTE => {
+            let mut bytes = [0u8; 8];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u64::from_be_bytes(bytes) as u128,
+                Endian::Little => u64::from_le_bytes(bytes) as u128,
+            })
+        }
+        U128_BYTE => {
+            let mut bytes = [0u8; 16];
+            read.read(&mut bytes)?;
+            Ok(match endian {
+                Endian::Big => u128::from_be_bytes(bytes),
+                Endian::Little => u128::from_le_bytes(bytes),
+            })
+        }
+        x => Ok(x as u128),
+    }
+}
+
+#[test]
+fn test_decode_u16() {
+    let cases: &[(&[u8], u16, u16)] = &[
+        (&[0], 0, 0),
+        (&[10], 10, 10),
+        (&[U16_BYTE, 0, 10], 2560, 10),
+    ];
+    for &(slice, expected_le, expected_be) in cases {
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u16(&mut reader, Endian::Little).unwrap();
+        assert_eq!(expected_le, found);
+
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u16(&mut reader, Endian::Big).unwrap();
+        assert_eq!(expected_be, found);
+    }
+}
+
+#[test]
+fn test_decode_u32() {
+    let cases: &[(&[u8], u32, u32)] = &[
+        (&[0], 0, 0),
+        (&[10], 10, 10),
+        (&[U16_BYTE, 0, 10], 2560, 10),
+        (&[U32_BYTE, 0, 0, 0, 10], 167_772_160, 10),
+    ];
+    for &(slice, expected_le, expected_be) in cases {
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u32(&mut reader, Endian::Little).unwrap();
+        assert_eq!(expected_le, found);
+
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u32(&mut reader, Endian::Big).unwrap();
+        assert_eq!(expected_be, found);
+    }
+}
+
+#[test]
+fn test_decode_u64() {
+    let cases: &[(&[u8], u64, u64)] = &[
+        (&[0], 0, 0),
+        (&[10], 10, 10),
+        (&[U16_BYTE, 0, 10], 2560, 10),
+        (&[U32_BYTE, 0, 0, 0, 10], 167_772_160, 10),
+        (
+            &[U64_BYTE, 0, 0, 0, 0, 0, 0, 0, 10],
+            72_057_594_037_9279_360,
+            10,
+        ),
+    ];
+    for &(slice, expected_le, expected_be) in cases {
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u64(&mut reader, Endian::Little).unwrap();
+        assert_eq!(expected_le, found);
+
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u64(&mut reader, Endian::Big).unwrap();
+        assert_eq!(expected_be, found);
+    }
+}
+
+#[test]
+fn test_decode_u128() {
+    let cases: &[(&[u8], u128, u128)] = &[
+        (&[0], 0, 0),
+        (&[10], 10, 10),
+        (&[U16_BYTE, 0, 10], 2560, 10),
+        (&[U32_BYTE, 0, 0, 0, 10], 167_772_160, 10),
+        (
+            &[U64_BYTE, 0, 0, 0, 0, 0, 0, 0, 10],
+            72_057_594_037_9279_360,
+            10,
+        ),
+        (
+            &[U128_BYTE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10],
+            13_292_279_957_849_158_729_038_070_602_803_445_760,
+            10,
+        ),
+    ];
+    for &(slice, expected_le, expected_be) in cases {
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u128(&mut reader, Endian::Little).unwrap();
+        assert_eq!(expected_le, found);
+
+        let mut reader = crate::de::read::SliceReader::new(slice);
+        let found = varint_decode_u128(&mut reader, Endian::Big).unwrap();
+        assert_eq!(expected_be, found);
+    }
+}
diff --git a/src/varint/mod.rs b/src/varint/mod.rs
index f6e761f..54d19e5 100644
--- a/src/varint/mod.rs
+++ b/src/varint/mod.rs
@@ -1,6 +1,11 @@
+mod decode_unsigned;
 mod encode_signed;
 mod encode_unsigned;
 
+pub use self::decode_unsigned::{
+    varint_decode_u128, varint_decode_u16, varint_decode_u32, varint_decode_u64,
+    varint_decode_usize,
+};
 pub use self::encode_signed::{
     varint_encode_i128, varint_encode_i16, varint_encode_i32, varint_encode_i64,
     varint_encode_isize,