Tidy file stream implementation, bump major version.

Author: tmpfs

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "binary_rw"
-version = "3.0.0"
+version = "4.0.0"
 authors = ["Mathias Danielsen <mathiasda98@hotmail.com>"]
 edition = "2021"
 

src/lib.rs

@@ -16,7 +16,7 @@ mod error;
 mod stream;
 
 pub use error::BinaryError;
-pub use stream::file::{FileStream, OpenType};
+pub use stream::file::FileStream;
 pub use stream::memory::MemoryStream;
 pub use stream::slice::SliceStream;
 

src/stream/file.rs

@@ -5,78 +5,69 @@ use std::io::prelude::*;
 use std::io::{Error, ErrorKind, Read, SeekFrom, Write};
 use std::path::Path;
 
-/// Indicates how the file stream should open the underlying file.
-pub enum OpenType {
-    /// Open and create the file if it does not exist.
-    ///
-    /// This will truncate the file if it already exists.
-    OpenAndCreate,
-
-    /// Open the file for reading and writing.
-    ReadWrite,
-
-    /// Open the file for reading.
-    Open,
-}
-
 /// Stream that wraps a file.
-pub struct FileStream {
-    file: File,
-}
+pub struct FileStream(File);
 
 impl FileStream {
     /// Create a file stream.
-    pub fn new<P: AsRef<Path>>(path: P, open_type: OpenType) -> Result<FileStream> {
-        let file = match open_type {
-            OpenType::OpenAndCreate => File::create(path)?,
-            OpenType::ReadWrite => OpenOptions::new().read(true).write(true).open(path)?,
-            OpenType::Open => File::open(path)?,
-        };
-        Ok(Self { file })
+    pub fn new(file: File) -> Self {
+        Self(file)
+    }
+
+    /// Create a file stream in write-only mode.
+    ///
+    /// If the file exists it is truncated, if it does not 
+    /// exist it will be created.
+    pub fn create<P: AsRef<Path>>(path: P) -> Result<Self> {
+        Ok(Self(File::create(path.as_ref())?))
+    }
+
+    /// Attempts to open a file stream in read-only mode.
+    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
+        Ok(Self(File::open(path.as_ref())?))
+    }
+
+    /// Attempts to open a file stream with read and write modes enabled.
+    pub fn write<P: AsRef<Path>>(path: P) -> Result<Self> {
+        Ok(Self(OpenOptions::new().read(true).write(true).open(path)?))
     }
 }
 
 impl SeekStream for FileStream {
     fn seek(&mut self, to: usize) -> Result<usize> {
-        Ok(self.file.seek(SeekFrom::Start(to as u64))? as usize)
+        Ok(self.0.seek(SeekFrom::Start(to as u64))? as usize)
     }
 
     fn tell(&mut self) -> Result<usize> {
-        Ok(self.file.seek(SeekFrom::Current(0))? as usize)
+        Ok(self.0.seek(SeekFrom::Current(0))? as usize)
     }
 
     fn len(&self) -> Result<usize> {
-        Ok(self.file.metadata()?.len().try_into()?)
+        Ok(self.0.metadata()?.len().try_into()?)
     }
 }
 
 impl Read for FileStream {
     fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
-        if self.tell().unwrap() + buffer.len() > self.file.metadata()?.len() as usize {
+        if self.tell().unwrap() + buffer.len() > self.0.metadata()?.len() as usize {
             return Err(Error::new(
                 ErrorKind::UnexpectedEof,
                 BinaryError::ReadPastEof,
             ));
         }
-        Ok(self.file.read(buffer)?)
+        Ok(self.0.read(buffer)?)
     }
 }
 
 impl Write for FileStream {
     fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
-        self.file.write(bytes)
+        self.0.write(bytes)
     }
 
     fn flush(&mut self) -> std::io::Result<()> {
-        self.file.flush()
+        self.0.flush()
     }
 }
 
 impl ReadStream for FileStream {}
 impl WriteStream for FileStream {}
-
-impl From<File> for FileStream {
-    fn from(file: File) -> Self {
-        Self { file }
-    }
-}

tests/lib.rs

@@ -1,16 +1,16 @@
 use anyhow::Result;
 use binary_rw::{
-    BinaryReader, BinaryWriter, Endian, FileStream, MemoryStream, OpenType, SeekStream, SliceStream,
+    BinaryReader, BinaryWriter, Endian, FileStream, MemoryStream, SeekStream, SliceStream,
 };
 
 fn create_writer_stream(name: &str) -> FileStream {
     let name = format!("{}.test", name);
-    FileStream::new(&name, OpenType::OpenAndCreate).expect("Failed to open stream")
+    FileStream::create(&name).expect("Failed to open stream")
 }
 
 fn create_reader_stream(name: &str) -> FileStream {
     let name = format!("{}.test", name);
-    FileStream::new(&name, OpenType::Open).expect("Failed to open stream")
+    FileStream::open(&name).expect("Failed to open stream")
 }
 
 fn cleanup(name: &str) {