rename bitbuffer/bitstream to bitreadbuffer/bitreadstream

src/lib.rs

@@ -16,7 +16,7 @@
 //!
 //! ```
 //! # use bitbuffer::Result;
-//! use bitbuffer::{BitBuffer, LittleEndian, BitStream, BitRead};
+//! use bitbuffer::{BitReadBuffer, LittleEndian, BitReadStream, BitRead};
 //!
 //! #[derive(BitRead)]
 //! struct ComplexType {
@@ -31,8 +31,8 @@
 //!     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
 //!     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
 //! ];
-//! let buffer = BitBuffer::new(bytes, LittleEndian);
-//! let mut stream = BitStream::new(buffer);
+//! let buffer = BitReadBuffer::new(bytes, LittleEndian);
+//! let mut stream = BitReadStream::new(buffer);
 //! let value: u8 = stream.read_int(7)?;
 //! let complex: ComplexType = stream.read()?;
 //! #
@@ -60,16 +60,16 @@ use std::fmt::Display;
 pub use std::string::FromUtf8Error;
 
 pub use bitbuffer_derive::{BitRead, BitReadSized};
-pub use buffer::BitBuffer;
 pub use endianness::*;
 pub use read::{BitRead, BitReadSized, LazyBitRead, LazyBitReadSized};
-pub use stream::BitStream;
+pub use readbuffer::BitReadBuffer;
+pub use readstream::BitReadStream;
 
-mod buffer;
 mod endianness;
 mod is_signed;
 mod read;
-mod stream;
+mod readbuffer;
+mod readstream;
 mod unchecked_primitive;
 
 /// Errors that can be returned when trying to read from a buffer

src/read.rs

@@ -1,5 +1,5 @@
 use crate::endianness::{BigEndian, LittleEndian};
-use crate::{BitStream, Endianness, Result};
+use crate::{BitReadStream, Endianness, Result};
 use std::cell::RefCell;
 use std::cmp::min;
 use std::collections::HashMap;
@@ -91,14 +91,14 @@ use std::sync::Arc;
 /// [read]: struct.BitStream.html#method.read
 pub trait BitRead<E: Endianness>: Sized {
     /// Read the type from stream
-    fn read(stream: &mut BitStream<E>) -> Result<Self>;
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self>;
 
     /// Note: only the bounds are unchecked
     ///
     /// any other validations (e.g. checking for valid utf8) still needs to be done
     #[doc(hidden)]
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
         Self::read(stream)
     }
 
@@ -106,7 +106,7 @@ pub trait BitRead<E: Endianness>: Sized {
     ///
     /// This might be faster than reading it if the size is known beforehand
     #[inline]
-    fn skip(stream: &mut BitStream<E>) -> Result<()> {
+    fn skip(stream: &mut BitReadStream<E>) -> Result<()> {
         match Self::bit_size() {
             Some(size) => stream.skip_bits(size),
             None => Self::read(stream).map(|_| ()),
@@ -125,12 +125,12 @@ macro_rules! impl_read_int {
     ($type:ty) => {
         impl<E: Endianness> BitRead<E> for $type {
             #[inline]
-            fn read(stream: &mut BitStream<E>) -> Result<$type> {
+            fn read(stream: &mut BitReadStream<E>) -> Result<$type> {
                 stream.read_int::<$type>(size_of::<$type>() * 8)
             }
 
             #[inline]
-            unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<$type> {
+            unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<$type> {
                 Ok(stream.read_int_unchecked::<$type>(size_of::<$type>() * 8))
             }
 
@@ -146,12 +146,12 @@ macro_rules! impl_read_int_nonzero {
     ($type:ty) => {
         impl BitRead<LittleEndian> for Option<$type> {
             #[inline]
-            fn read(stream: &mut BitStream<LittleEndian>) -> Result<Self> {
+            fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
                 Ok(<$type>::new(stream.read()?))
             }
 
             #[inline]
-            unsafe fn read_unchecked(stream: &mut BitStream<LittleEndian>) -> Result<Self> {
+            unsafe fn read_unchecked(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
                 Ok(<$type>::new(
                     stream.read_int_unchecked(size_of::<$type>() * 8),
                 ))
@@ -165,12 +165,12 @@ macro_rules! impl_read_int_nonzero {
 
         impl BitRead<BigEndian> for Option<$type> {
             #[inline]
-            fn read(stream: &mut BitStream<BigEndian>) -> Result<Self> {
+            fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
                 Ok(<$type>::new(stream.read()?))
             }
 
             #[inline]
-            unsafe fn read_unchecked(stream: &mut BitStream<BigEndian>) -> Result<Self> {
+            unsafe fn read_unchecked(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
                 Ok(<$type>::new(
                     stream.read_int_unchecked(size_of::<$type>() * 8),
                 ))
@@ -203,12 +203,12 @@ impl_read_int_nonzero!(std::num::NonZeroU128);
 
 impl<E: Endianness> BitRead<E> for f32 {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<f32> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<f32> {
         stream.read_float::<f32>()
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<f32> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<f32> {
         Ok(stream.read_float_unchecked::<f32>())
     }
 
@@ -220,12 +220,12 @@ impl<E: Endianness> BitRead<E> for f32 {
 
 impl<E: Endianness> BitRead<E> for f64 {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<f64> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<f64> {
         stream.read_float::<f64>()
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<f64> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<f64> {
         Ok(stream.read_float_unchecked::<f64>())
     }
 
@@ -237,12 +237,12 @@ impl<E: Endianness> BitRead<E> for f64 {
 
 impl<E: Endianness> BitRead<E> for bool {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<bool> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<bool> {
         stream.read_bool()
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<bool> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<bool> {
         Ok(stream.read_bool_unchecked())
     }
 
@@ -254,19 +254,19 @@ impl<E: Endianness> BitRead<E> for bool {
 
 impl<E: Endianness> BitRead<E> for String {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<String> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<String> {
         stream.read_string(None)
     }
 }
 
 impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Rc::new(T::read(stream)?))
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Rc::new(T::read_unchecked(stream)?))
     }
 
@@ -278,12 +278,12 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
 
 impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Arc::new(T::read(stream)?))
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Arc::new(T::read_unchecked(stream)?))
     }
 
@@ -295,12 +295,12 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
 
 impl<E: Endianness, T: BitRead<E>> BitRead<E> for Box<T> {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Box::new(T::read(stream)?))
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
         Ok(Box::new(T::read_unchecked(stream)?))
     }
 
@@ -314,12 +314,12 @@ macro_rules! impl_read_tuple {
     ($($type:ident),*) => {
         impl<E: Endianness, $($type: BitRead<E>),*> BitRead<E> for ($($type),*) {
             #[inline]
-            fn read(stream: &mut BitStream<E>) -> Result<Self> {
+            fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
                 Ok(($(<$type>::read(stream)?),*))
             }
 
             #[inline]
-            unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
+            unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
                 Ok(($(<$type>::read_unchecked(stream)?),*))
             }
 
@@ -401,11 +401,11 @@ impl_read_tuple!(T1, T2, T3, T4);
 /// [read]: struct.BitStream.html#method.read
 pub trait BitReadSized<E: Endianness>: Sized {
     /// Read the type from stream
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self>;
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self>;
 
     #[doc(hidden)]
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         Self::read(stream, size)
     }
 
@@ -413,7 +413,7 @@ pub trait BitReadSized<E: Endianness>: Sized {
     ///
     /// This might be faster than reading it if the size is known beforehand
     #[inline]
-    fn skip(stream: &mut BitStream<E>, size: usize) -> Result<()> {
+    fn skip(stream: &mut BitReadStream<E>, size: usize) -> Result<()> {
         match Self::bit_size_sized(size) {
             Some(size) => stream.skip_bits(size),
             None => Self::read(stream, size).map(|_| ()),
@@ -432,12 +432,12 @@ macro_rules! impl_read_int_sized {
     ( $ type: ty) => {
         impl<E: Endianness> BitReadSized<E> for $type {
             #[inline]
-            fn read(stream: &mut BitStream<E>, size: usize) -> Result<$type> {
+            fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> {
                 stream.read_int::<$type>(size)
             }
 
             #[inline]
-            unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<$type> {
+            unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> {
                 Ok(stream.read_int_unchecked::<$type>(size))
             }
 
@@ -462,7 +462,7 @@ impl_read_int_sized!(i128);
 
 impl<E: Endianness> BitReadSized<E> for String {
     #[inline]
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<String> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<String> {
         stream.read_string(Some(size))
     }
 
@@ -474,7 +474,7 @@ impl<E: Endianness> BitReadSized<E> for String {
 
 /// Read a boolean, if true, read `T`, else return `None`
 impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
-    fn read(stream: &mut BitStream<E>) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
         if stream.read()? {
             Ok(Some(stream.read()?))
         } else {
@@ -484,7 +484,7 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
 }
 
 impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         if stream.read()? {
             Ok(Some(stream.read_sized(size)?))
         } else {
@@ -493,9 +493,9 @@ impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
     }
 }
 
-impl<E: Endianness> BitReadSized<E> for BitStream<E> {
+impl<E: Endianness> BitReadSized<E> for BitReadStream<E> {
     #[inline]
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         stream.read_bits(size)
     }
 
@@ -507,7 +507,7 @@ impl<E: Endianness> BitReadSized<E> for BitStream<E> {
 
 /// Read `T` `size` times and return as `Vec<T>`
 impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         let mut vec = Vec::with_capacity(min(size, 128));
         for _ in 0..size {
             vec.push(stream.read()?)
@@ -516,7 +516,7 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         let mut vec = Vec::with_capacity(min(size, 128));
         for _ in 0..size {
             vec.push(stream.read_unchecked()?)
@@ -533,14 +533,14 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
 // Once we have something like https://github.com/rust-lang/rfcs/issues/1053 we can do this optimization
 //impl<E: Endianness> ReadSized<E> for Vec<u8> {
 //    #[inline]
-//    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+//    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
 //        stream.read_bytes(size)
 //    }
 //}
 
 /// Read `K` and `T` `size` times and return as `HashMap<K, T>`
 impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> for HashMap<K, T> {
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         let mut map = HashMap::with_capacity(min(size, 128));
         for _ in 0..size {
             let key = stream.read()?;
@@ -551,7 +551,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
     }
 
     #[inline]
-    unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         let mut map = HashMap::with_capacity(min(size, 128));
         for _ in 0..size {
             let key = stream.read_unchecked()?;
@@ -574,7 +574,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
 #[derive(Clone, Debug)]
 /// Struct that lazily reads it's contents from the stream
 pub struct LazyBitRead<T: BitRead<E>, E: Endianness> {
-    source: BitStream<E>,
+    source: BitReadStream<E>,
     inner_type: PhantomData<T>,
 }
 
@@ -588,7 +588,7 @@ impl<T: BitRead<E>, E: Endianness> LazyBitRead<T, E> {
 
 impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> {
     #[inline]
-    fn read(stream: &mut BitStream<E>) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
         match T::bit_size() {
             Some(bit_size) => Ok(LazyBitRead {
                 source: stream.read_bits(bit_size)?,
@@ -607,7 +607,7 @@ impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> {
 #[derive(Clone, Debug)]
 /// Struct that lazily reads it's contents from the stream
 pub struct LazyBitReadSized<T: BitReadSized<E>, E: Endianness> {
-    source: RefCell<BitStream<E>>,
+    source: RefCell<BitReadStream<E>>,
     size: usize,
     inner_type: PhantomData<T>,
 }
@@ -622,7 +622,7 @@ impl<T: BitReadSized<E>, E: Endianness> LazyBitReadSized<T, E> {
 
 impl<T: BitReadSized<E>, E: Endianness> BitReadSized<E> for LazyBitReadSized<T, E> {
     #[inline]
-    fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
+    fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
         match T::bit_size_sized(size) {
             Some(bit_size) => Ok(LazyBitReadSized {
                 source: RefCell::new(stream.read_bits(bit_size)?),

src/readbuffer.rs

@@ -21,21 +21,21 @@ const USIZE_SIZE: usize = size_of::<usize>();
 /// # Examples
 ///
 /// ```
-/// use bitbuffer::{BitBuffer, LittleEndian, Result};
+/// use bitbuffer::{BitReadBuffer, LittleEndian, Result};
 ///
 /// # fn main() -> Result<()> {
 /// let bytes = vec![
 ///     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
 ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
 /// ];
-/// let buffer = BitBuffer::new(bytes, LittleEndian);
+/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
 /// // read 7 bits as u8, starting from bit 3
 /// let result: u8 = buffer.read_int(3, 7)?;
 /// #
 /// #     Ok(())
 /// # }
 /// ```
-pub struct BitBuffer<E>
+pub struct BitReadBuffer<E>
 where
     E: Endianness,
 {
@@ -44,7 +44,7 @@ where
     endianness: PhantomData<E>,
 }
 
-impl<E> BitBuffer<E>
+impl<E> BitReadBuffer<E>
 where
     E: Endianness,
 {
@@ -53,20 +53,20 @@ where
     /// # Examples
     ///
     /// ```
-    /// use bitbuffer::{BitBuffer, LittleEndian};
+    /// use bitbuffer::{BitReadBuffer, LittleEndian};
     ///
     /// let bytes = vec![
     ///     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
-    /// let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// ```
     pub fn new(mut bytes: Vec<u8>, _endianness: E) -> Self {
         let byte_len = bytes.len();
 
         // pad with usize worth of bytes to ensure we can always read a full usize
         bytes.extend_from_slice(&0usize.to_le_bytes());
-        BitBuffer {
+        BitReadBuffer {
             bytes: Rc::new(bytes),
             bit_len: byte_len * 8,
             endianness: PhantomData,
@@ -74,7 +74,7 @@ where
     }
 }
 
-impl<E> BitBuffer<E>
+impl<E> BitReadBuffer<E>
 where
     E: Endianness,
 {
@@ -137,14 +137,14 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// let result = buffer.read_bool(5)?;
     /// assert_eq!(result, true);
     /// #
@@ -191,14 +191,14 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// let result = buffer.read_int::<u16>(10, 9)?;
     /// assert_eq!(result, 0b100_0110_10);
     /// #
@@ -327,14 +327,14 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// assert_eq!(buffer.read_bytes(5, 3)?, &[0b0_1010_101, 0b0_1100_011, 0b1_1001_101]);
     /// assert_eq!(buffer.read_bytes(0, 8)?, &[
     ///     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
@@ -407,7 +407,7 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
@@ -416,7 +416,7 @@ where
     /// #     0x72, 0x6c, 0x64, 0,
     /// #     0,    0,    0,    0
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// // Fixed length string
     /// assert_eq!(buffer.read_string(0, Some(13))?, "Hello world".to_owned());
     /// // fixed length with null padding
@@ -499,14 +499,14 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
     /// let result = buffer.read_float::<f32>(10)?;
     /// #
     /// #     Ok(())
@@ -564,7 +564,7 @@ where
             });
         }
 
-        Ok(BitBuffer {
+        Ok(BitReadBuffer {
             bytes: Rc::clone(&self.bytes),
             bit_len,
             endianness: PhantomData,
@@ -572,10 +572,10 @@ where
     }
 }
 
-impl<E: Endianness> From<Vec<u8>> for BitBuffer<E> {
+impl<E: Endianness> From<Vec<u8>> for BitReadBuffer<E> {
     fn from(bytes: Vec<u8>) -> Self {
         let byte_len = bytes.len();
-        BitBuffer {
+        BitReadBuffer {
             bytes: Rc::new(bytes),
             bit_len: byte_len * 8,
             endianness: PhantomData,
@@ -583,9 +583,9 @@ impl<E: Endianness> From<Vec<u8>> for BitBuffer<E> {
     }
 }
 
-impl<E: Endianness> Clone for BitBuffer<E> {
+impl<E: Endianness> Clone for BitReadBuffer<E> {
     fn clone(&self) -> Self {
-        BitBuffer {
+        BitReadBuffer {
             bytes: Rc::clone(&self.bytes),
             bit_len: self.bit_len(),
             endianness: PhantomData,
@@ -593,7 +593,7 @@ impl<E: Endianness> Clone for BitBuffer<E> {
     }
 }
 
-impl<E: Endianness> Debug for BitBuffer<E> {
+impl<E: Endianness> Debug for BitReadBuffer<E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,

src/readstream.rs

@@ -6,7 +6,7 @@ use num_traits::{Float, PrimInt};
 use crate::endianness::Endianness;
 use crate::is_signed::IsSigned;
 use crate::unchecked_primitive::{UncheckedPrimitiveFloat, UncheckedPrimitiveInt};
-use crate::BitBuffer;
+use crate::BitReadBuffer;
 use crate::{BitRead, BitReadSized, ReadError, Result};
 use std::cmp::min;
 
@@ -15,28 +15,28 @@ use std::cmp::min;
 /// # Examples
 ///
 /// ```
-/// use bitbuffer::{BitBuffer, BitStream, LittleEndian};
+/// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
 ///
 /// let bytes = vec![
 ///     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
 ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
 /// ];
-/// let buffer = BitBuffer::new(bytes, LittleEndian);
-/// let mut stream = BitStream::new(buffer);
+/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
+/// let mut stream = BitReadStream::new(buffer);
 /// ```
 ///
 /// [`BitBuffer`]: struct.BitBuffer.html
 #[derive(Debug)]
-pub struct BitStream<E>
+pub struct BitReadStream<E>
 where
     E: Endianness,
 {
-    buffer: BitBuffer<E>,
+    buffer: BitReadBuffer<E>,
     start_pos: usize,
     pos: usize,
 }
 
-impl<E> BitStream<E>
+impl<E> BitReadStream<E>
 where
     E: Endianness,
 {
@@ -45,19 +45,19 @@ where
     /// # Examples
     ///
     /// ```
-    /// use bitbuffer::{BitBuffer, BitStream, LittleEndian};
+    /// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
     ///
     /// let bytes = vec![
     ///     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     ///     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// ];
-    /// let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// let mut stream = BitStream::new(buffer);
+    /// let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// let mut stream = BitReadStream::new(buffer);
     /// ```
     ///
     /// [`BitBuffer`]: struct.BitBuffer.html
-    pub fn new(buffer: BitBuffer<E>) -> Self {
-        BitStream {
+    pub fn new(buffer: BitReadBuffer<E>) -> Self {
+        BitReadStream {
             start_pos: 0,
             pos: 0,
             buffer,
@@ -73,15 +73,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.read_bool()?, true);
     /// assert_eq!(stream.read_bool()?, false);
     /// assert_eq!(stream.pos(), 2);
@@ -118,15 +118,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.read_int::<u16>(3)?, 0b101);
     /// assert_eq!(stream.read_int::<u16>(3)?, 0b110);
     /// assert_eq!(stream.pos(), 6);
@@ -169,15 +169,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let result = stream.read_float::<f32>()?;
     /// assert_eq!(stream.pos(), 32);
     /// #
@@ -220,15 +220,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.read_bytes(3)?, &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
     /// assert_eq!(stream.pos(), 24);
     /// #
@@ -268,7 +268,7 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
@@ -277,8 +277,8 @@ where
     /// #     0x72, 0x6c, 0x64, 0,
     /// #     0,    0,    0,    0
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// // Fixed length string
     /// stream.set_pos(0);
     /// assert_eq!(stream.read_string(Some(11))?, "Hello world".to_owned());
@@ -345,15 +345,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let mut bits = stream.read_bits(3)?;
     /// assert_eq!(stream.pos(), 3);
     /// assert_eq!(bits.pos(), 0);
@@ -368,7 +368,7 @@ where
     ///
     /// [`ReadError::NotEnoughData`]: enum.ReadError.html#variant.NotEnoughData
     pub fn read_bits(&mut self, count: usize) -> Result<Self> {
-        let result = BitStream {
+        let result = BitReadStream {
             buffer: self.buffer.get_sub_buffer(self.pos + count)?,
             start_pos: self.pos,
             pos: self.pos,
@@ -386,15 +386,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// stream.skip_bits(3)?;
     /// assert_eq!(stream.pos(), 3);
     /// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
@@ -425,15 +425,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// stream.set_pos(3)?;
     /// assert_eq!(stream.pos(), 3);
     /// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
@@ -459,15 +459,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.bit_len(), 64);
     /// #
     /// #     Ok(())
@@ -482,15 +482,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.pos(), 0);
     /// stream.skip_bits(5)?;
     /// assert_eq!(stream.pos(), 5);
@@ -507,15 +507,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// assert_eq!(stream.bits_left(), 64);
     /// stream.skip_bits(5)?;
     /// assert_eq!(stream.bits_left(), 59);
@@ -532,15 +532,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let int: u8 = stream.read()?;
     /// assert_eq!(int, 0b1011_0101);
     /// let boolean: bool = stream.read()?;
@@ -551,7 +551,7 @@ where
     /// ```
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// use bitbuffer::BitRead;
     /// #
     /// #[derive(BitRead, Debug, PartialEq)]
@@ -567,8 +567,8 @@ where
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let data: ComplexType = stream.read()?;
     /// assert_eq!(data, ComplexType {
     ///     first: 0b1011_0101,
@@ -597,15 +597,15 @@ where
     /// # Examples
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let int: u8 = stream.read_sized(7)?;
     /// assert_eq!(int, 0b011_0101);
     /// #
@@ -614,15 +614,15 @@ where
     /// ```
     ///
     /// ```
-    /// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
+    /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
     /// #
     /// # fn main() -> Result<()> {
     /// # let bytes = vec![
     /// #     0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
     /// #     0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
     /// # ];
-    /// # let buffer = BitBuffer::new(bytes, LittleEndian);
-    /// # let mut stream = BitStream::new(buffer);
+    /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
+    /// # let mut stream = BitReadStream::new(buffer);
     /// let data: Vec<u16> = stream.read_sized(3)?;
     /// assert_eq!(data, vec![0b0110_1010_1011_0101, 0b1001_1001_1010_1100, 0b1001_1001_1001_1001]);
     /// #
@@ -653,9 +653,9 @@ where
     }
 }
 
-impl<E: Endianness> Clone for BitStream<E> {
+impl<E: Endianness> Clone for BitReadStream<E> {
     fn clone(&self) -> Self {
-        BitStream {
+        BitReadStream {
             buffer: self.buffer.clone(),
             start_pos: self.pos,
             pos: self.pos,
@@ -663,14 +663,14 @@ impl<E: Endianness> Clone for BitStream<E> {
     }
 }
 
-impl<E: Endianness> From<BitBuffer<E>> for BitStream<E> {
-    fn from(buffer: BitBuffer<E>) -> Self {
-        BitStream::new(buffer)
+impl<E: Endianness> From<BitReadBuffer<E>> for BitReadStream<E> {
+    fn from(buffer: BitReadBuffer<E>) -> Self {
+        BitReadStream::new(buffer)
     }
 }
 
-impl<E: Endianness> From<Vec<u8>> for BitStream<E> {
+impl<E: Endianness> From<Vec<u8>> for BitReadStream<E> {
     fn from(bytes: Vec<u8>) -> Self {
-        BitStream::new(BitBuffer::from(bytes))
+        BitReadStream::new(BitReadBuffer::from(bytes))
     }
 }