A new IO-Layer

Author: alexkazik

src/dir.rs

@@ -15,7 +15,7 @@ use crate::dir_entry::{SFN_PADDING, SFN_SIZE};
 use crate::error::{Error, IoError};
 use crate::file::File;
 use crate::fs::{DiskSlice, FileSystem, FsIoAdapter, OemCpConverter, ReadWriteSeek};
-use crate::io::{self, IoBase, Read, Seek, SeekFrom, Write};
+use crate::io::{self, IoBase, ReadFile, Seek, SeekFrom, WriteFile};
 use crate::time::TimeProvider;
 
 const LFN_PADDING: u16 = 0xFFFF;
@@ -55,7 +55,7 @@ impl<IO: ReadWriteSeek, TP, OCC> IoBase for DirRawStream<'_, IO, TP, OCC> {
     type Error = Error<IO::Error>;
 }
 
-impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for DirRawStream<'_, IO, TP, OCC> {
+impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> ReadFile for DirRawStream<'_, IO, TP, OCC> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         match self {
             DirRawStream::File(file) => file.read(buf),
@@ -64,7 +64,7 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for DirRawStream<'_, IO, TP,
     }
 }
 
-impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Write for DirRawStream<'_, IO, TP, OCC> {
+impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> WriteFile for DirRawStream<'_, IO, TP, OCC> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         match self {
             DirRawStream::File(file) => file.write(buf),
@@ -73,8 +73,8 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Write for DirRawStream<'_, IO, TP
     }
     fn flush(&mut self) -> Result<(), Self::Error> {
         match self {
-            DirRawStream::File(file) => file.flush(),
-            DirRawStream::Root(raw) => raw.flush(),
+            DirRawStream::File(file) => WriteFile::flush(file),
+            DirRawStream::Root(raw) => WriteFile::flush(raw),
         }
     }
 }

src/file.rs

@@ -3,7 +3,7 @@ use core::convert::TryFrom;
 use crate::dir_entry::DirEntryEditor;
 use crate::error::Error;
 use crate::fs::{FileSystem, ReadWriteSeek};
-use crate::io::{IoBase, Read, Seek, SeekFrom, Write};
+use crate::io::{IoBase, ReadFile, Seek, SeekFrom, Write, WriteFile};
 use crate::time::{Date, DateTime, TimeProvider};
 
 const MAX_FILE_SIZE: u32 = core::u32::MAX;
@@ -254,7 +254,7 @@ impl<IO: ReadWriteSeek, TP, OCC> IoBase for File<'_, IO, TP, OCC> {
     type Error = Error<IO::Error>;
 }
 
-impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for File<'_, IO, TP, OCC> {
+impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> ReadFile for File<'_, IO, TP, OCC> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         trace!("File::read");
         let cluster_size = self.fs.cluster_size();
@@ -286,15 +286,10 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for File<'_, IO, TP, OCC> {
         }
         trace!("read {} bytes in cluster {}", read_size, current_cluster);
         let offset_in_fs = self.fs.offset_from_cluster(current_cluster) + u64::from(offset_in_cluster);
-        let read_bytes = {
-            let mut disk = self.fs.disk.borrow_mut();
-            disk.seek(SeekFrom::Start(offset_in_fs))?;
-            disk.read(&mut buf[..read_size])?
-        };
-        if read_bytes == 0 {
-            return Ok(0);
-        }
-        self.offset += read_bytes as u32;
+        let mut disk = self.fs.disk.borrow_mut();
+        disk.seek(SeekFrom::Start(offset_in_fs))?;
+        disk.read_exact(&mut buf[..read_size])?;
+        self.offset += read_size as u32;
         self.current_cluster = Some(current_cluster);
 
         if let Some(ref mut e) = self.entry {
@@ -303,7 +298,7 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for File<'_, IO, TP, OCC> {
                 e.set_accessed(now);
             }
         }
-        Ok(read_bytes)
+        Ok(read_size)
     }
 }
 
@@ -313,11 +308,11 @@ where
     std::io::Error: From<Error<IO::Error>>,
 {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        Ok(Read::read(self, buf)?)
+        Ok(ReadFile::read(self, buf)?)
     }
 }
 
-impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Write for File<'_, IO, TP, OCC> {
+impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> WriteFile for File<'_, IO, TP, OCC> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         trace!("File::write");
         let cluster_size = self.fs.cluster_size();
@@ -365,19 +360,14 @@ impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Write for File<'_, IO, TP, OCC> {
         };
         trace!("write {} bytes in cluster {}", write_size, current_cluster);
         let offset_in_fs = self.fs.offset_from_cluster(current_cluster) + u64::from(offset_in_cluster);
-        let written_bytes = {
-            let mut disk = self.fs.disk.borrow_mut();
-            disk.seek(SeekFrom::Start(offset_in_fs))?;
-            disk.write(&buf[..write_size])?
-        };
-        if written_bytes == 0 {
-            return Ok(0);
-        }
+        let mut disk = self.fs.disk.borrow_mut();
+        disk.seek(SeekFrom::Start(offset_in_fs))?;
+        disk.write_all(&buf[..write_size])?;
         // some bytes were writter - update position and optionally size
-        self.offset += written_bytes as u32;
+        self.offset += write_size as u32;
         self.current_cluster = Some(current_cluster);
         self.update_dir_entry_after_write();
-        Ok(written_bytes)
+        Ok(write_size)
     }
 
     fn flush(&mut self) -> Result<(), Self::Error> {
@@ -391,7 +381,8 @@ where
     std::io::Error: From<Error<IO::Error>>,
 {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        Ok(Write::write(self, buf)?)
+        Write::write_all(self, buf)?;
+        Ok(buf.len())
     }
 
     fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {

src/fs.rs

@@ -13,7 +13,7 @@ use crate::dir::{Dir, DirRawStream};
 use crate::dir_entry::{DirFileEntryData, FileAttributes, SFN_PADDING, SFN_SIZE};
 use crate::error::Error;
 use crate::file::File;
-use crate::io::{self, IoBase, Read, ReadLeExt, Seek, SeekFrom, Write, WriteLeExt};
+use crate::io::{self, IoBase, Read, ReadFile, ReadLeExt, Seek, SeekFrom, Write, WriteFile, WriteLeExt};
 use crate::table::{
     alloc_cluster, count_free_clusters, format_fat, read_fat_flags, ClusterIterator, RESERVED_FAT_ENTRIES,
 };
@@ -699,18 +699,19 @@ impl<IO: ReadWriteSeek, TP, OCC> IoBase for FsIoAdapter<'_, IO, TP, OCC> {
 }
 
 impl<IO: ReadWriteSeek, TP, OCC> Read for FsIoAdapter<'_, IO, TP, OCC> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        self.fs.disk.borrow_mut().read(buf)
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
+        self.fs.disk.borrow_mut().read_exact(buf)
     }
 }
 
 impl<IO: ReadWriteSeek, TP, OCC> Write for FsIoAdapter<'_, IO, TP, OCC> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        let size = self.fs.disk.borrow_mut().write(buf)?;
-        if size > 0 {
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        if buf.is_empty() {
+            Ok(())
+        } else {
             self.fs.set_dirty_flag(true)?;
+            self.fs.disk.borrow_mut().write_all(buf)
         }
-        Ok(size)
     }
 
     fn flush(&mut self) -> Result<(), Self::Error> {
@@ -801,18 +802,18 @@ impl<B, S: IoBase> IoBase for DiskSlice<B, S> {
     type Error = Error<S::Error>;
 }
 
-impl<B: BorrowMut<S>, S: Read + Seek> Read for DiskSlice<B, S> {
+impl<B: BorrowMut<S>, S: Read + Seek> ReadFile for DiskSlice<B, S> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         let offset = self.begin + self.offset;
         let read_size = (buf.len() as u64).min(self.size - self.offset) as usize;
         self.inner.borrow_mut().seek(SeekFrom::Start(offset))?;
-        let size = self.inner.borrow_mut().read(&mut buf[..read_size])?;
-        self.offset += size as u64;
-        Ok(size)
+        self.inner.borrow_mut().read_exact(&mut buf[..read_size])?;
+        self.offset += read_size as u64;
+        Ok(read_size)
     }
 }
 
-impl<B: BorrowMut<S>, S: Write + Seek> Write for DiskSlice<B, S> {
+impl<B: BorrowMut<S>, S: Write + Seek> WriteFile for DiskSlice<B, S> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         let offset = self.begin + self.offset;
         let write_size = (buf.len() as u64).min(self.size - self.offset) as usize;

src/io.rs

@@ -13,6 +13,28 @@ pub trait IoBase {
 ///
 /// It is based on the `std::io::Read` trait.
 pub trait Read: IoBase {
+    /// Read the exact number of bytes required to fill `buf`.
+    ///
+    /// This function reads as many bytes as necessary to completely fill the specified buffer `buf`.
+    ///
+    /// # Errors
+    ///
+    /// If this function encounters an error for which `IoError::is_interrupted` returns true then the error is ignored
+    /// and the operation will continue.
+    ///
+    /// If this function encounters an end of file before completely filling the buffer, it returns an error
+    /// instantiated by a call to `IoError::new_unexpected_eof_error`. The contents of `buf` are unspecified in this
+    /// case.
+    ///
+    /// If this function returns an error, it is unspecified how many bytes it has read, but it will never read more
+    /// than would be necessary to completely fill the buffer.
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error>;
+}
+
+/// The `ReadFile` trait allows for reading bytes from a source.
+///
+/// It is based on the `std::io::Read` trait.
+pub trait ReadFile: Read {
     /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
     ///
     /// This function does not provide any guarantees about whether it blocks waiting for data, but if an object needs
@@ -74,10 +96,42 @@ pub trait Read: IoBase {
     }
 }
 
+impl<T: ReadFile> Read for T {
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
+        ReadFile::read_exact(self, buf)
+    }
+}
+
 /// The `Write` trait allows for writing bytes into the sink.
 ///
 /// It is based on the `std::io::Write` trait.
 pub trait Write: IoBase {
+    /// Attempts to write an entire buffer into this writer.
+    ///
+    /// This method will continuously call `write` until there is no more data to be written or an error is returned.
+    /// Errors for which `IoError::is_interrupted` method returns true are being skipped. This method will not return
+    /// until the entire buffer has been successfully written or such an error occurs.
+    /// If `write` returns 0 before the entire buffer has been written this method will return an error instantiated by
+    /// a call to `IoError::new_write_zero_error`.
+    ///
+    /// # Errors
+    ///
+    /// This function will return the first error for which `IoError::is_interrupted` method returns false that `write`
+    /// returns.
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>;
+
+    /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
+    ///
+    /// # Errors
+    ///
+    /// It is considered an error if not all bytes could be written due to I/O errors or EOF being reached.
+    fn flush(&mut self) -> Result<(), Self::Error>;
+}
+
+/// The `WriteFile` trait allows for writing bytes into the sink.
+///
+/// It is based on the `std::io::Write` trait.
+pub trait WriteFile: Write {
     /// Write a buffer into this writer, returning how many bytes were written.
     ///
     /// # Errors
@@ -122,6 +176,16 @@ pub trait Write: IoBase {
     fn flush(&mut self) -> Result<(), Self::Error>;
 }
 
+impl<T: WriteFile> Write for T {
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        WriteFile::write_all(self, buf)
+    }
+
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        WriteFile::flush(self)
+    }
+}
+
 /// Enumeration of possible methods to seek within an I/O object.
 ///
 /// It is based on the `std::io::SeekFrom` enum.
@@ -201,7 +265,7 @@ impl<T> IoBase for StdIoWrapper<T> {
 }
 
 #[cfg(feature = "std")]
-impl<T: std::io::Read> Read for StdIoWrapper<T> {
+impl<T: std::io::Read> ReadFile for StdIoWrapper<T> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         self.inner.read(buf)
     }
@@ -212,10 +276,6 @@ impl<T: std::io::Read> Read for StdIoWrapper<T> {
 
 #[cfg(feature = "std")]
 impl<T: std::io::Write> Write for StdIoWrapper<T> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        self.inner.write(buf)
-    }
-
     fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
         self.inner.write_all(buf)
     }