Merge pull request #45 from felixwrt/rename_byte_source_types

rename `*Reader` types to `*ByteSource` (e.g. `IoReader` to `IoByteSource`)

CHANGELOG.md

@@ -16,6 +16,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Decoder improvements (#43)
+- **BREAKING:** Renamed `*Reader` types to `*ByteSource` (e.g. `IoReader` to `IoByteSource`) (#45)
+
 
 ## [0.4.0] - 2024-06-04
 

src/lib.rs

@@ -219,7 +219,7 @@ where
     decoder: DecoderReader<Buf, R>,
 }
 
-pub(crate) type DummySmlReader = SmlReader<util::SliceReader<'static>, ArrayBuf<0>>;
+pub(crate) type DummySmlReader = SmlReader<util::SliceByteSource<'static>, ArrayBuf<0>>;
 
 impl DummySmlReader {
     /// Returns a builder with a static internal buffer of size `N`.
@@ -268,12 +268,12 @@ impl DummySmlReader {
     /// let reader = SmlReader::from_reader(cursor);
     /// ```
     #[cfg(feature = "std")]
-    pub fn from_reader<R>(reader: R) -> SmlReader<util::IoReader<R>, DefaultBuffer>
+    pub fn from_reader<R>(reader: R) -> SmlReader<util::IoByteSource<R>, DefaultBuffer>
     where
         R: std::io::Read,
     {
         SmlReader {
-            decoder: DecoderReader::new(util::IoReader::new(reader)),
+            decoder: DecoderReader::new(util::IoByteSource::new(reader)),
         }
     }
 
@@ -297,12 +297,12 @@ impl DummySmlReader {
     /// let reader = SmlReader::from_eh_reader(pin);
     /// ```
     #[cfg(feature = "embedded_hal")]
-    pub fn from_eh_reader<R, E>(reader: R) -> SmlReader<util::EhReader<R, E>, DefaultBuffer>
+    pub fn from_eh_reader<R, E>(reader: R) -> SmlReader<util::EhByteSource<R, E>, DefaultBuffer>
     where
         R: embedded_hal::serial::Read<u8, Error = E>,
     {
         SmlReader {
-            decoder: DecoderReader::new(util::EhReader::new(reader)),
+            decoder: DecoderReader::new(util::EhByteSource::new(reader)),
         }
     }
 
@@ -315,9 +315,9 @@ impl DummySmlReader {
     /// let data: &[u8] = &[1, 2, 3];
     /// let reader = SmlReader::from_slice(data);
     /// ```
-    pub fn from_slice(reader: &[u8]) -> SmlReader<util::SliceReader<'_>, DefaultBuffer> {
+    pub fn from_slice(reader: &[u8]) -> SmlReader<util::SliceByteSource<'_>, DefaultBuffer> {
         SmlReader {
-            decoder: DecoderReader::new(util::SliceReader::new(reader)),
+            decoder: DecoderReader::new(util::SliceByteSource::new(reader)),
         }
     }
 
@@ -336,13 +336,13 @@ impl DummySmlReader {
     /// ```
     pub fn from_iterator<B, I>(
         iter: I,
-    ) -> SmlReader<util::IterReader<I::IntoIter, B>, DefaultBuffer>
+    ) -> SmlReader<util::IterByteSource<I::IntoIter, B>, DefaultBuffer>
     where
         I: IntoIterator<Item = B>,
         B: Borrow<u8>,
     {
         SmlReader {
-            decoder: DecoderReader::new(util::IterReader::new(iter.into_iter())),
+            decoder: DecoderReader::new(util::IterByteSource::new(iter.into_iter())),
         }
     }
 }
@@ -510,9 +510,9 @@ impl<Buf: Buffer> SmlReaderBuilder<Buf> {
     /// let reader = SmlReader::with_static_buffer::<1024>().from_reader(cursor);
     /// ```
     #[cfg(feature = "std")]
-    pub fn from_reader<R: std::io::Read>(self, reader: R) -> SmlReader<util::IoReader<R>, Buf> {
+    pub fn from_reader<R: std::io::Read>(self, reader: R) -> SmlReader<util::IoByteSource<R>, Buf> {
         SmlReader {
-            decoder: DecoderReader::new(util::IoReader::new(reader)),
+            decoder: DecoderReader::new(util::IoByteSource::new(reader)),
         }
     }
 
@@ -539,9 +539,9 @@ impl<Buf: Buffer> SmlReaderBuilder<Buf> {
     pub fn from_eh_reader<R: embedded_hal::serial::Read<u8, Error = E>, E>(
         self,
         reader: R,
-    ) -> SmlReader<util::EhReader<R, E>, Buf> {
+    ) -> SmlReader<util::EhByteSource<R, E>, Buf> {
         SmlReader {
-            decoder: DecoderReader::new(util::EhReader::new(reader)),
+            decoder: DecoderReader::new(util::EhByteSource::new(reader)),
         }
     }
 
@@ -554,9 +554,9 @@ impl<Buf: Buffer> SmlReaderBuilder<Buf> {
     /// let data: &[u8] = &[1, 2, 3];
     /// let reader = SmlReader::with_static_buffer::<1024>().from_slice(data);
     /// ```
-    pub fn from_slice(self, reader: &[u8]) -> SmlReader<util::SliceReader<'_>, Buf> {
+    pub fn from_slice(self, reader: &[u8]) -> SmlReader<util::SliceByteSource<'_>, Buf> {
         SmlReader {
-            decoder: DecoderReader::new(util::SliceReader::new(reader)),
+            decoder: DecoderReader::new(util::SliceByteSource::new(reader)),
         }
     }
 
@@ -574,13 +574,16 @@ impl<Buf: Buffer> SmlReaderBuilder<Buf> {
     /// let reader = builder.clone().from_iterator(data.iter());       // impl Iterator<Item = &u8>
     /// let reader = builder.clone().from_iterator(data.into_iter());  // impl Iterator<Item = u8>
     /// ```
-    pub fn from_iterator<B, I>(self, iter: I) -> SmlReader<util::IterReader<I::IntoIter, B>, Buf>
+    pub fn from_iterator<B, I>(
+        self,
+        iter: I,
+    ) -> SmlReader<util::IterByteSource<I::IntoIter, B>, Buf>
     where
         I: IntoIterator<Item = B>,
         B: Borrow<u8>,
     {
         SmlReader {
-            decoder: DecoderReader::new(util::IterReader::new(iter.into_iter())),
+            decoder: DecoderReader::new(util::IterByteSource::new(iter.into_iter())),
         }
     }
 }

src/util.rs

@@ -182,25 +182,25 @@ pub trait ByteSourceErr: private::Sealed {
 
 /// Wraps types that implement `std::io::Read` and implements `ByteSource`
 #[cfg(feature = "std")]
-pub struct IoReader<R>
+pub struct IoByteSource<R>
 where
     R: std::io::Read,
 {
     inner: R,
 }
 
 #[cfg(feature = "std")]
-impl<R> IoReader<R>
+impl<R> IoByteSource<R>
 where
     R: std::io::Read,
 {
     pub(crate) fn new(reader: R) -> Self {
-        IoReader { inner: reader }
+        IoByteSource { inner: reader }
     }
 }
 
 #[cfg(feature = "std")]
-impl<R> ByteSource for IoReader<R>
+impl<R> ByteSource for IoByteSource<R>
 where
     R: std::io::Read,
 {
@@ -214,7 +214,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<R> private::Sealed for IoReader<R> where R: std::io::Read {}
+impl<R> private::Sealed for IoByteSource<R> where R: std::io::Read {}
 
 #[cfg(feature = "std")]
 impl ByteSourceErr for std::io::Error {
@@ -232,25 +232,25 @@ impl private::Sealed for std::io::Error {}
 
 /// Wraps types that implement `embedded_hal::serial::Read<...>` and implements `ByteSource`
 #[cfg(feature = "embedded_hal")]
-pub struct EhReader<R, E>
+pub struct EhByteSource<R, E>
 where
     R: embedded_hal::serial::Read<u8, Error = E>,
 {
     inner: R,
 }
 
 #[cfg(feature = "embedded_hal")]
-impl<R, E> EhReader<R, E>
+impl<R, E> EhByteSource<R, E>
 where
     R: embedded_hal::serial::Read<u8, Error = E>,
 {
     pub(crate) fn new(reader: R) -> Self {
-        EhReader { inner: reader }
+        EhByteSource { inner: reader }
     }
 }
 
 #[cfg(feature = "embedded_hal")]
-impl<R, E> ByteSource for EhReader<R, E>
+impl<R, E> ByteSource for EhByteSource<R, E>
 where
     R: embedded_hal::serial::Read<u8, Error = E>,
 {
@@ -262,7 +262,7 @@ where
 }
 
 #[cfg(feature = "embedded_hal")]
-impl<R, E> private::Sealed for EhReader<R, E> where R: embedded_hal::serial::Read<u8, Error = E> {}
+impl<R, E> private::Sealed for EhByteSource<R, E> where R: embedded_hal::serial::Read<u8, Error = E> {}
 
 #[cfg(feature = "embedded_hal")]
 impl<E> ByteSourceErr for nb::Error<E> {
@@ -295,21 +295,21 @@ impl ByteSourceErr for Eof {
 impl private::Sealed for Eof {}
 
 /// Wraps byte slices and implements `ByteSource`
-pub struct SliceReader<'i> {
+pub struct SliceByteSource<'i> {
     inner: &'i [u8],
     idx: usize,
 }
 
-impl<'i> SliceReader<'i> {
+impl<'i> SliceByteSource<'i> {
     pub(crate) fn new(slice: &'i [u8]) -> Self {
-        SliceReader {
+        SliceByteSource {
             inner: slice,
             idx: 0,
         }
     }
 }
 
-impl<'i> ByteSource for SliceReader<'i> {
+impl<'i> ByteSource for SliceByteSource<'i> {
     type ReadError = Eof;
 
     fn read_byte(&mut self) -> Result<u8, Self::ReadError> {
@@ -322,28 +322,28 @@ impl<'i> ByteSource for SliceReader<'i> {
     }
 }
 
-impl<'i> private::Sealed for SliceReader<'i> {}
+impl<'i> private::Sealed for SliceByteSource<'i> {}
 
 /// Wraps byte iterators and implements `ByteSource`
-pub struct IterReader<I, B>
+pub struct IterByteSource<I, B>
 where
     I: Iterator<Item = B>,
     B: Borrow<u8>,
 {
     iter: I,
 }
 
-impl<I, B> IterReader<I, B>
+impl<I, B> IterByteSource<I, B>
 where
     I: Iterator<Item = B>,
     B: Borrow<u8>,
 {
     pub(crate) fn new(iter: I) -> Self {
-        IterReader { iter }
+        IterByteSource { iter }
     }
 }
 
-impl<I, B> ByteSource for IterReader<I, B>
+impl<I, B> ByteSource for IterByteSource<I, B>
 where
     I: Iterator<Item = B>,
     B: Borrow<u8>,
@@ -358,7 +358,7 @@ where
     }
 }
 
-impl<I, B> private::Sealed for IterReader<I, B>
+impl<I, B> private::Sealed for IterByteSource<I, B>
 where
     I: Iterator<Item = B>,
     B: Borrow<u8>,