rename read -> read_int

src/buffer.rs

@@ -1,6 +1,6 @@
-use crate::{ReadError, Result};
 use crate::endianness::Endianness;
 use crate::is_signed::IsSigned;
+use crate::{ReadError, Result};
 use num_traits::{Float, PrimInt};
 use std::cmp::min;
 use std::marker::PhantomData;
@@ -62,10 +62,11 @@ impl IsPadded for Padded {
 /// ];
 /// let buffer = BitBuffer::from_padded_slice(bytes, 8, LittleEndian);
 /// ```
+#[derive(Copy)]
 pub struct BitBuffer<'a, E, S>
-    where
+where
-        E: Endianness,
+    E: Endianness,
-        S: IsPadded,
+    S: IsPadded,
 {
     bytes: &'a [u8],
     bit_len: usize,
@@ -75,8 +76,8 @@ pub struct BitBuffer<'a, E, S>
 }
 
 impl<'a, E> BitBuffer<'a, E, NonPadded>
-    where
+where
-        E: Endianness,
+    E: Endianness,
 {
     /// Create a new BitBuffer from a byte slice
     ///
@@ -104,8 +105,8 @@ impl<'a, E> BitBuffer<'a, E, NonPadded>
 }
 
 impl<'a, E> BitBuffer<'a, E, Padded>
-    where
+where
-        E: Endianness,
+    E: Endianness,
 {
     /// Create a new BitBuffer from a byte slice with included padding
     ///
@@ -146,9 +147,9 @@ impl<'a, E> BitBuffer<'a, E, Padded>
 }
 
 impl<'a, E, S> BitBuffer<'a, E, S>
-    where
+where
-        E: Endianness,
+    E: Endianness,
-        S: IsPadded,
+    S: IsPadded,
 {
     /// The available number of bits in the buffer
     pub fn bit_len(&self) -> usize {
@@ -174,8 +175,10 @@ impl<'a, E, S> BitBuffer<'a, E, S>
         };
         let bit_offset = position - byte_index * 8;
         let raw_container: &usize = unsafe {
-            // this is only safe for us because we're sure that there is enough data in the slice
+            // this is safe here because it's already verified that there is enough data in the slice
-            std::mem::transmute(self.bytes.as_ptr().offset(byte_index as isize))
+            // to read a usize from byte_index
+            let ptr = self.bytes.as_ptr().add(byte_index);
+            std::mem::transmute(ptr)
         };
         let container = if E::is_le() {
             usize::from_le(*raw_container)
@@ -185,7 +188,7 @@ impl<'a, E, S> BitBuffer<'a, E, S>
         let shifted = if E::is_le() {
             container >> bit_offset
         } else {
-            container >> USIZE_SIZE * 8 - bit_offset - count
+            container >> (USIZE_SIZE * 8 - bit_offset - count)
         };
         let mask = !(usize::max_value() << count);
         Ok(shifted & mask)
@@ -243,12 +246,12 @@ impl<'a, E, S> BitBuffer<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let result = buffer.read::<u16>(10, 9).unwrap();
+    /// let result = buffer.read_int::<u16>(10, 9).unwrap();
     /// assert_eq!(result, 0b100_0110_10);
     /// ```
-    pub fn read<T>(&self, position: usize, count: usize) -> Result<T>
+    pub fn read_int<T>(&self, position: usize, count: usize) -> Result<T>
-        where
+    where
-            T: PrimInt + BitOrAssign + IsSigned,
+        T: PrimInt + BitOrAssign + IsSigned,
     {
         let value = {
             let type_bit_size = size_of::<T>() * 8;
@@ -379,7 +382,7 @@ impl<'a, E, S> BitBuffer<'a, E, S>
                 let mut acc = vec![];
                 let mut pos = position;
                 loop {
-                    let byte = self.read(pos, 8)?;
+                    let byte = self.read_int(pos, 8)?;
                     acc.push(byte);
                     if byte == 0 {
                         break;
@@ -413,15 +416,31 @@ impl<'a, E, S> BitBuffer<'a, E, S>
     /// let result = buffer.read_float::<f32>(10).unwrap();
     /// ```
     pub fn read_float<T>(&self, position: usize) -> Result<T>
-        where
+    where
-            T: Float,
+        T: Float,
     {
         if size_of::<T>() == 4 {
-            let int = self.read::<u32>(position, 32)?;
+            let int = self.read_int::<u32>(position, 32)?;
             Ok(T::from(f32::from_bits(int)).unwrap())
         } else {
-            let int = self.read::<u64>(position, 64)?;
+            let int = self.read_int::<u64>(position, 64)?;
             Ok(T::from(f64::from_bits(int)).unwrap())
         }
     }
 }
+
+impl<'a, E, P> Clone for BitBuffer<'a, E, P>
+where
+    E: Endianness,
+    P: IsPadded,
+{
+    fn clone(&self) -> Self {
+        BitBuffer {
+            bytes: self.bytes,
+            byte_len: self.byte_len,
+            bit_len: self.bit_len,
+            endianness: PhantomData,
+            is_padded: PhantomData,
+        }
+    }
+}

src/is_signed.rs

@@ -17,9 +17,11 @@ impl_is_signed!(u8, false);
 impl_is_signed!(u16, false);
 impl_is_signed!(u32, false);
 impl_is_signed!(u64, false);
+impl_is_signed!(u128, false);
 impl_is_signed!(usize, false);
 impl_is_signed!(i8, true);
 impl_is_signed!(i16, true);
 impl_is_signed!(i32, true);
 impl_is_signed!(i64, true);
+impl_is_signed!(i128, true);
 impl_is_signed!(isize, true);

src/lib.rs

@@ -6,7 +6,7 @@
 // for bench on nightly
 //extern crate test;
 
-pub use buffer::{BitBuffer, IsPadded};
+pub use buffer::{BitBuffer, IsPadded, NonPadded, Padded};
 pub use endianness::*;
 pub use std::string::FromUtf8Error;
 pub use stream::BitStream;

src/stream.rs

@@ -1,11 +1,13 @@
-use crate::{ReadError, Result};
+use std::mem::size_of;
-use crate::BitBuffer;
+use std::ops::BitOrAssign;
+
+use num_traits::{Float, PrimInt};
+
 use crate::buffer::IsPadded;
 use crate::endianness::Endianness;
 use crate::is_signed::IsSigned;
-use num_traits::{Float, PrimInt};
+use crate::BitBuffer;
-use std::mem::size_of;
+use crate::{ReadError, Result};
-use std::ops::BitOrAssign;
 
 /// Stream that provides an easy way to iterate trough a BitBuffer
 ///
@@ -19,26 +21,31 @@ use std::ops::BitOrAssign;
 ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
 /// ];
 /// let buffer = BitBuffer::new(bytes, LittleEndian);
-/// let mut stream = BitStream::new(&buffer, None, None);
+/// let mut stream = BitStream::new(buffer, None, None);
 /// ```
 pub struct BitStream<'a, E, S>
-    where
+where
-        E: Endianness,
+    E: Endianness,
-        S: IsPadded,
+    S: IsPadded,
 {
-    buffer: &'a BitBuffer<'a, E, S>,
+    buffer: BitBuffer<'a, E, S>,
     start_pos: usize,
     pos: usize,
     bit_len: usize,
 }
 
 impl<'a, E, S> BitStream<'a, E, S>
-    where
+where
-        E: Endianness,
+    E: Endianness,
-        S: IsPadded,
+    S: IsPadded,
 {
     /// Create a new stream for a buffer
     ///
+    /// # Panics
+    ///
+    /// - If the start_pos is higher than the bit length of the buffer
+    ///
+    ///
     /// # Examples
     ///
     /// ```
@@ -49,17 +56,22 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// ```
     pub fn new(
-        buffer: &'a BitBuffer<'a, E, S>,
+        buffer: BitBuffer<'a, E, S>,
         start_pos: Option<usize>,
         bit_len: Option<usize>,
     ) -> Self {
+        let buffer_len = buffer.bit_len();
+        let start = start_pos.unwrap_or_default();
+        if start > buffer_len {
+            panic!("start_pos out opf bounds of the buffer")
+        }
         BitStream {
-            start_pos: start_pos.unwrap_or(0),
+            start_pos: start,
-            pos: start_pos.unwrap_or(0),
+            pos: start,
-            bit_len: bit_len.unwrap_or(buffer.bit_len()),
+            bit_len: bit_len.unwrap_or(buffer_len - start),
             buffer,
         }
     }
@@ -91,7 +103,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// assert_eq!(stream.read_bool().unwrap(), true);
     /// assert_eq!(stream.read_bool().unwrap(), false);
     /// assert_eq!(stream.pos(), 2);
@@ -99,9 +111,8 @@ impl<'a, E, S> BitStream<'a, E, S>
     pub fn read_bool(&mut self) -> Result<bool> {
         self.verify_bits_left(1)?;
         let result = self.buffer.read_bool(self.pos);
-        match result {
+        if result.is_ok() {
-            Ok(_) => self.pos += 1,
+            self.pos += 1;
-            Err(_) => {}
         }
         result
     }
@@ -123,20 +134,19 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
-    /// assert_eq!(stream.read::<u16>(3).unwrap(), 0b101);
+    /// assert_eq!(stream.read_int::<u16>(3).unwrap(), 0b101);
-    /// assert_eq!(stream.read::<u16>(3).unwrap(), 0b110);
+    /// assert_eq!(stream.read_int::<u16>(3).unwrap(), 0b110);
     /// assert_eq!(stream.pos(), 6);
     /// ```
-    pub fn read<T>(&mut self, count: usize) -> Result<T>
+    pub fn read_int<T>(&mut self, count: usize) -> Result<T>
-        where
+    where
-            T: PrimInt + BitOrAssign + IsSigned,
+        T: PrimInt + BitOrAssign + IsSigned,
     {
         self.verify_bits_left(count)?;
-        let result = self.buffer.read(self.pos, count);
+        let result = self.buffer.read_int(self.pos, count);
-        match result {
+        if result.is_ok() {
-            Ok(_) => self.pos += count,
+            self.pos += count;
-            Err(_) => {}
         }
         result
     }
@@ -157,20 +167,19 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// let result = stream.read_float::<f32>().unwrap();
     /// assert_eq!(stream.pos(), 32);
     /// ```
     pub fn read_float<T>(&mut self) -> Result<T>
-        where
+    where
-            T: Float,
+        T: Float,
     {
         let count = size_of::<T>() * 8;
         self.verify_bits_left(count)?;
         let result = self.buffer.read_float(self.pos);
-        match result {
+        if result.is_ok() {
-            Ok(_) => self.pos += count,
+            self.pos += count;
-            Err(_) => {}
         }
         result
     }
@@ -191,7 +200,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// assert_eq!(stream.read_bytes(3).unwrap(), &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
     /// assert_eq!(stream.pos(), 24);
     /// ```
@@ -199,9 +208,8 @@ impl<'a, E, S> BitStream<'a, E, S>
         let count = byte_count * 8;
         self.verify_bits_left(count)?;
         let result = self.buffer.read_bytes(self.pos, byte_count);
-        match result {
+        if result.is_ok() {
-            Ok(_) => self.pos += count,
+            self.pos += count;
-            Err(_) => {}
         }
         result
     }
@@ -227,7 +235,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0,    0,    0,    0
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// // Fixed length string
     /// stream.set_pos(0);
     /// assert_eq!(stream.read_string(Some(11)).unwrap(), "Hello world".to_owned());
@@ -245,7 +253,7 @@ impl<'a, E, S> BitStream<'a, E, S>
         let result = self.buffer.read_string(self.pos, byte_len)?;
         let read = match byte_len {
             Some(len) => len * 8,
-            None => (result.len() + 1) * 8
+            None => (result.len() + 1) * 8,
         };
         self.pos += read;
         Ok(result)
@@ -267,17 +275,17 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// let mut bits = stream.read_bits(3).unwrap();
     /// assert_eq!(stream.pos(), 3);
     /// assert_eq!(bits.pos(), 0);
     /// assert_eq!(bits.bit_len(), 3);
-    /// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
+    /// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
-    /// assert_eq!(bits.read::<u8>(3).unwrap(), 0b101);
+    /// assert_eq!(bits.read_int::<u8>(3).unwrap(), 0b101);
     /// ```
     pub fn read_bits(&mut self, count: usize) -> Result<Self> {
         self.verify_bits_left(count)?;
-        let result = BitStream::new(&self.buffer, Some(self.pos), Some(count));
+        let result = BitStream::new(self.buffer.clone(), Some(self.pos), Some(count));
         self.pos += count;
         Ok(result)
     }
@@ -298,10 +306,10 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// stream.skip(3).unwrap();
     /// assert_eq!(stream.pos(), 3);
-    /// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
+    /// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
     /// ```
     pub fn skip(&mut self, count: usize) -> Result<()> {
         self.verify_bits_left(count)?;
@@ -325,10 +333,10 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// stream.set_pos(3).unwrap();
     /// assert_eq!(stream.pos(), 3);
-    /// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
+    /// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
     /// ```
     pub fn set_pos(&mut self, pos: usize) -> Result<()> {
         if pos > self.bit_len {
@@ -353,7 +361,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// assert_eq!(stream.bit_len(), 64);
     /// ```
     pub fn bit_len(&self) -> usize {
@@ -372,7 +380,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// assert_eq!(stream.pos(), 0);
     /// stream.skip(5).unwrap();
     /// assert_eq!(stream.pos(), 5);
@@ -393,7 +401,7 @@ impl<'a, E, S> BitStream<'a, E, S>
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
     /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(&buffer, None, None);
+    /// let mut stream = BitStream::new(buffer, None, None);
     /// assert_eq!(stream.bits_left(), 64);
     /// stream.skip(5).unwrap();
     /// assert_eq!(stream.bits_left(), 59);

src/tests.rs

@@ -22,38 +22,39 @@ const BYTES: &'static [u8] = &[
 fn read_u8_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read::<u8>(0, 1).unwrap(), 0b1);
+    assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
-    assert_eq!(buffer.read::<u8>(1, 1).unwrap(), 0b0);
+    assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
-    assert_eq!(buffer.read::<u8>(2, 2).unwrap(), 0b01);
+    assert_eq!(buffer.read_int::<u8>(2, 2).unwrap(), 0b01);
-    assert_eq!(buffer.read::<u8>(0, 3).unwrap(), 0b101);
+    assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
-    assert_eq!(buffer.read::<u8>(7, 5).unwrap(), 0b1010_1);
+    assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1010_1);
-    assert_eq!(buffer.read::<u8>(6, 5).unwrap(), 0b010_10);
+    assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b010_10);
+    assert_eq!(buffer.read_int::<u8>(12, 5).unwrap(), 0b0_0110);
 }
 
 #[test]
 fn read_u8_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read::<u8>(0, 1).unwrap(), 0b1);
+    assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
-    assert_eq!(buffer.read::<u8>(1, 1).unwrap(), 0b0);
+    assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
-    assert_eq!(buffer.read::<u8>(2, 2).unwrap(), 0b11);
+    assert_eq!(buffer.read_int::<u8>(2, 2).unwrap(), 0b11);
-    assert_eq!(buffer.read::<u8>(0, 3).unwrap(), 0b101);
+    assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
-    assert_eq!(buffer.read::<u8>(7, 5).unwrap(), 0b1011_0);
+    assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1011_0);
-    assert_eq!(buffer.read::<u8>(6, 5).unwrap(), 0b01_011);
+    assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b01_011);
 }
 
 #[test]
 fn read_u16_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
+    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
 }
 
 #[test]
 fn read_u16_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
+    assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
 }
 
 #[test]
@@ -61,7 +62,7 @@ fn read_u32_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
     assert_eq!(
-        buffer.read::<u32>(6, 24).unwrap(),
+        buffer.read_int::<u32>(6, 24).unwrap(),
         0b01_1001_1010_1100_0110_1010_10
     );
 }
@@ -71,7 +72,7 @@ fn read_u32_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
     assert_eq!(
-        buffer.read::<u32>(6, 24).unwrap(),
+        buffer.read_int::<u32>(6, 24).unwrap(),
         0b01_0110_1010_1010_1100_1001_10
     );
 }
@@ -81,19 +82,19 @@ fn read_u64_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
     assert_eq!(
-        buffer.read::<u64>(6, 34).unwrap(),
+        buffer.read_int::<u64>(6, 34).unwrap(),
         0b1001_1001_1001_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<u64>(6, 60).unwrap(),
+        buffer.read_int::<u64>(6, 60).unwrap(),
         0b01_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<u64>(6, 64).unwrap(),
+        buffer.read_int::<u64>(6, 64).unwrap(),
         0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<u64>(8, 62).unwrap(),
+        buffer.read_int::<u64>(8, 62).unwrap(),
         0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010
     );
 }
@@ -103,15 +104,15 @@ fn read_u64_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
     assert_eq!(
-        buffer.read::<u64>(6, 34).unwrap(),
+        buffer.read_int::<u64>(6, 34).unwrap(),
         0b01_0110_1010_1010_1100_1001_1001_1001_1001
     );
     assert_eq!(
-        buffer.read::<u64>(6, 60).unwrap(),
+        buffer.read_int::<u64>(6, 60).unwrap(),
         0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_10
     );
     assert_eq!(
-        buffer.read::<u64>(6, 64).unwrap(),
+        buffer.read_int::<u64>(6, 64).unwrap(),
         0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_10
     );
 }
@@ -120,33 +121,33 @@ fn read_u64_be() {
 fn read_i8_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read::<i8>(0, 3).unwrap(), -0b01);
+    assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
-    assert_eq!(buffer.read::<i8>(0, 8).unwrap(), -0b011_0101);
+    assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b011_0101);
 }
 
 #[test]
 fn read_i8_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read::<i8>(1, 2).unwrap(), 0b1);
+    assert_eq!(buffer.read_int::<i8>(1, 2).unwrap(), 0b1);
-    assert_eq!(buffer.read::<i8>(0, 3).unwrap(), -0b01);
+    assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
-    assert_eq!(buffer.read::<i8>(0, 8).unwrap(), -0b011_0101);
+    assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b011_0101);
 }
 
 #[test]
 fn read_i16_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
-    assert_eq!(buffer.read::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
+    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
-    assert_eq!(buffer.read::<i16>(6, 13).unwrap(), -0b00_0110_1010_10);
+    assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b00_0110_1010_10);
 }
 
 #[test]
 fn read_i16_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
-    assert_eq!(buffer.read::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
+    assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
-    assert_eq!(buffer.read::<i16>(7, 12).unwrap(), -0b0110_1010_101);
+    assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b0110_1010_101);
 }
 
 #[test]
@@ -154,11 +155,11 @@ fn read_i32_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
     assert_eq!(
-        buffer.read::<i32>(6, 24).unwrap(),
+        buffer.read_int::<i32>(6, 24).unwrap(),
         0b1_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<i32>(6, 26).unwrap(),
+        buffer.read_int::<i32>(6, 26).unwrap(),
         -0b001_1001_1010_1100_0110_1010_10
     );
 }
@@ -168,7 +169,7 @@ fn read_i32_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
     assert_eq!(
-        buffer.read::<i32>(7, 24).unwrap(),
+        buffer.read_int::<i32>(7, 24).unwrap(),
         -0b0110_1010_1010_1100_1001_100
     );
 }
@@ -178,15 +179,15 @@ fn read_i64_le() {
     let buffer = BitBuffer::new(BYTES, LittleEndian);
 
     assert_eq!(
-        buffer.read::<i64>(6, 34).unwrap(),
+        buffer.read_int::<i64>(6, 34).unwrap(),
         -0b001_1001_1001_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<i64>(6, 59).unwrap(),
+        buffer.read_int::<i64>(6, 59).unwrap(),
         -0b1110_01111001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
     );
     assert_eq!(
-        buffer.read::<i64>(1, 64).unwrap(),
+        buffer.read_int::<i64>(1, 64).unwrap(),
         -0b1110_01111001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_1011_010
     );
 }
@@ -196,15 +197,15 @@ fn read_i64_be() {
     let buffer = BitBuffer::new(BYTES, BigEndian);
 
     assert_eq!(
-        buffer.read::<i64>(7, 34).unwrap(),
+        buffer.read_int::<i64>(7, 34).unwrap(),
         -0b0110_1010_1010_1100_1001_1001_1001_1001_1
     );
     assert_eq!(
-        buffer.read::<i64>(7, 60).unwrap(),
+        buffer.read_int::<i64>(7, 60).unwrap(),
         -0b0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_100
     );
     assert_eq!(
-        buffer.read::<i64>(7, 64).unwrap(),
+        buffer.read_int::<i64>(7, 64).unwrap(),
         -0b0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_100
     );
 }