aud_io: Move IO utils from lofty

Author: Serial-ATA

aud_io/src/error.rs

@@ -15,6 +15,8 @@ pub enum AudioError {
 	StringFromUtf8(std::string::FromUtf8Error),
 	/// Unable to convert bytes to a str
 	StrFromUtf8(std::str::Utf8Error),
+	/// This should **never** be encountered
+	Infallible(std::convert::Infallible),
 }
 
 impl From<std::io::Error> for AudioError {
@@ -35,6 +37,12 @@ impl From<std::str::Utf8Error> for AudioError {
 	}
 }
 
+impl From<std::convert::Infallible> for AudioError {
+	fn from(input: std::convert::Infallible) -> Self {
+		AudioError::Infallible(input)
+	}
+}
+
 impl Display for AudioError {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
@@ -43,6 +51,7 @@ impl Display for AudioError {
 			AudioError::StrFromUtf8(err) => write!(f, "{err}"),
 			AudioError::Io(err) => write!(f, "{err}"),
 			AudioError::TextDecode(message) => write!(f, "Text decoding: {message}"),
+			AudioError::Infallible(_) => write!(f, "An expected condition was not upheld"),
 		}
 	}
 }

aud_io/src/io.rs

@@ -0,0 +1,231 @@
+//! Various traits for reading and writing to file-like objects
+
+use crate::error::{AudioError, Result};
+use crate::math::F80;
+
+use std::collections::VecDeque;
+use std::fs::File;
+use std::io::{Cursor, Read, Seek, Write};
+
+/// Provides a method to truncate an object to the specified length
+///
+/// This is one component of the [`FileLike`] trait, which is used to provide implementors access to any
+/// file saving methods such as [`AudioFile::save_to`](crate::file::AudioFile::save_to).
+///
+/// Take great care in implementing this for downstream types, as Lofty will assume that the
+/// container has the new length specified. If this assumption were to be broken, files **will** become corrupted.
+///
+/// # Examples
+///
+/// ```rust
+/// use lofty::io::Truncate;
+///
+/// let mut data = vec![1, 2, 3, 4, 5];
+/// data.truncate(3);
+///
+/// assert_eq!(data, vec![1, 2, 3]);
+/// ```
+pub trait Truncate {
+	/// The error type of the truncation operation
+	type Error: Into<AudioError>;
+
+	/// Truncate a storage object to the specified length
+	///
+	/// # Errors
+	///
+	/// Errors depend on the object being truncated, which may not always be fallible.
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error>;
+}
+
+impl Truncate for File {
+	type Error = std::io::Error;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		self.set_len(new_len)
+	}
+}
+
+impl Truncate for Vec<u8> {
+	type Error = std::convert::Infallible;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		self.truncate(new_len as usize);
+		Ok(())
+	}
+}
+
+impl Truncate for VecDeque<u8> {
+	type Error = std::convert::Infallible;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		self.truncate(new_len as usize);
+		Ok(())
+	}
+}
+
+impl<T> Truncate for Cursor<T>
+where
+	T: Truncate,
+{
+	type Error = <T as Truncate>::Error;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		self.get_mut().truncate(new_len)
+	}
+}
+
+impl<T> Truncate for Box<T>
+where
+	T: Truncate,
+{
+	type Error = <T as Truncate>::Error;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		self.as_mut().truncate(new_len)
+	}
+}
+
+impl<T> Truncate for &mut T
+where
+	T: Truncate,
+{
+	type Error = <T as Truncate>::Error;
+
+	fn truncate(&mut self, new_len: u64) -> std::result::Result<(), Self::Error> {
+		(**self).truncate(new_len)
+	}
+}
+
+/// Provides a method to get the length of a storage object
+///
+/// This is one component of the [`FileLike`] trait, which is used to provide implementors access to any
+/// file saving methods such as [`AudioFile::save_to`](crate::file::AudioFile::save_to).
+///
+/// Take great care in implementing this for downstream types, as Lofty will assume that the
+/// container has the exact length specified. If this assumption were to be broken, files **may** become corrupted.
+///
+/// # Examples
+///
+/// ```rust
+/// use lofty::io::Length;
+///
+/// let data = vec![1, 2, 3, 4, 5];
+/// assert_eq!(data.len(), 5);
+/// ```
+pub trait Length {
+	/// The error type of the length operation
+	type Error: Into<AudioError>;
+
+	/// Get the length of a storage object
+	///
+	/// # Errors
+	///
+	/// Errors depend on the object being read, which may not always be fallible.
+	fn len(&self) -> std::result::Result<u64, Self::Error>;
+}
+
+impl Length for File {
+	type Error = std::io::Error;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		self.metadata().map(|m| m.len())
+	}
+}
+
+impl Length for Vec<u8> {
+	type Error = std::convert::Infallible;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Ok(self.len() as u64)
+	}
+}
+
+impl Length for VecDeque<u8> {
+	type Error = std::convert::Infallible;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Ok(self.len() as u64)
+	}
+}
+
+impl<T> Length for Cursor<T>
+where
+	T: Length,
+{
+	type Error = <T as Length>::Error;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Length::len(self.get_ref())
+	}
+}
+
+impl<T> Length for Box<T>
+where
+	T: Length,
+{
+	type Error = <T as Length>::Error;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Length::len(self.as_ref())
+	}
+}
+
+impl<T> Length for &T
+where
+	T: Length,
+{
+	type Error = <T as Length>::Error;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Length::len(*self)
+	}
+}
+
+impl<T> Length for &mut T
+where
+	T: Length,
+{
+	type Error = <T as Length>::Error;
+
+	fn len(&self) -> std::result::Result<u64, Self::Error> {
+		Length::len(*self)
+	}
+}
+
+/// Provides a set of methods to read and write to a file-like object
+///
+/// This is a combination of the [`Read`], [`Write`], [`Seek`], [`Truncate`], and [`Length`] traits.
+/// It is used to provide implementors access to any file saving methods such as [`AudioFile::save_to`](crate::file::AudioFile::save_to).
+///
+/// Take great care in implementing this for downstream types, as Lofty will assume that the
+/// trait implementations are correct. If this assumption were to be broken, files **may** become corrupted.
+pub trait FileLike: Read + Write + Seek + Truncate + Length
+where
+	<Self as Truncate>::Error: Into<AudioError>,
+	<Self as Length>::Error: Into<AudioError>,
+{
+}
+
+impl<T> FileLike for T
+where
+	T: Read + Write + Seek + Truncate + Length,
+	<T as Truncate>::Error: Into<AudioError>,
+	<T as Length>::Error: Into<AudioError>,
+{
+}
+
+pub trait ReadExt: Read {
+	fn read_f80(&mut self) -> Result<F80>;
+}
+
+impl<R> ReadExt for R
+where
+	R: Read,
+{
+	fn read_f80(&mut self) -> Result<F80> {
+		let mut bytes = [0; 10];
+		self.read_exact(&mut bytes)?;
+
+		Ok(F80::from_be_bytes(bytes))
+	}
+}

aud_io/src/lib.rs

@@ -2,3 +2,4 @@ pub mod text;
 pub mod error;
 pub(crate) mod macros;
 pub mod math;
+pub mod io;

lofty/src/ape/tag/mod.rs

@@ -11,12 +11,12 @@ use crate::tag::{
 	Accessor, ItemKey, ItemValue, MergeTag, SplitTag, Tag, TagExt, TagItem, TagType, try_parse_year,
 };
 use crate::util::flag_item;
-use crate::util::io::{FileLike, Truncate};
 
 use std::borrow::Cow;
 use std::io::Write;
 use std::ops::Deref;
 
+use aud_io::io::{FileLike, Truncate};
 use lofty_attr::tag;
 
 macro_rules! impl_accessor {

lofty/src/ape/tag/write.rs

@@ -8,10 +8,10 @@ use crate::id3::{FindId3v2Config, find_id3v1, find_id3v2, find_lyrics3v2};
 use crate::macros::{decode_err, err};
 use crate::probe::Probe;
 use crate::tag::item::ItemValueRef;
-use crate::util::io::{FileLike, Truncate};
 
 use std::io::{Cursor, Seek, SeekFrom, Write};
 
+use aud_io::io::{FileLike, Truncate};
 use byteorder::{LittleEndian, WriteBytesExt};
 
 #[allow(clippy::shadow_unrelated)]

lofty/src/error.rs

@@ -70,8 +70,6 @@ pub enum ErrorKind {
 	Fmt(std::fmt::Error),
 	/// Failure to allocate enough memory
 	Alloc(TryReserveError),
-	/// This should **never** be encountered
-	Infallible(std::convert::Infallible),
 }
 
 /// The types of errors that can occur while interacting with ID3v2 tags
@@ -506,7 +504,7 @@ impl From<std::collections::TryReserveError> for LoftyError {
 impl From<std::convert::Infallible> for LoftyError {
 	fn from(input: std::convert::Infallible) -> Self {
 		Self {
-			kind: ErrorKind::Infallible(input),
+			kind: ErrorKind::AudioIo(AudioError::Infallible(input)),
 		}
 	}
 }
@@ -554,8 +552,6 @@ impl Display for LoftyError {
 			),
 			ErrorKind::FileDecoding(ref file_decode_err) => write!(f, "{file_decode_err}"),
 			ErrorKind::FileEncoding(ref file_encode_err) => write!(f, "{file_encode_err}"),
-
-			ErrorKind::Infallible(_) => write!(f, "A expected condition was not upheld"),
 		}
 	}
 }

lofty/src/file/audio_file.rs

@@ -3,11 +3,12 @@ use crate::config::{ParseOptions, WriteOptions};
 use crate::error::{LoftyError, Result};
 use crate::tag::TagType;
 
-use crate::util::io::{FileLike, Length, Truncate};
 use std::fs::OpenOptions;
 use std::io::{Read, Seek};
 use std::path::Path;
 
+use aud_io::io::{FileLike, Length, Truncate};
+
 /// Provides various methods for interaction with a file
 pub trait AudioFile: Into<TaggedFile> {
 	/// The struct the file uses for audio properties

lofty/src/file/tagged_file.rs

@@ -4,10 +4,11 @@ use crate::config::{ParseOptions, WriteOptions};
 use crate::error::{LoftyError, Result};
 use crate::properties::FileProperties;
 use crate::tag::{Tag, TagExt, TagSupport, TagType};
-use crate::util::io::{FileLike, Length, Truncate};
 
 use std::io::{Read, Seek};
 
+use aud_io::io::{FileLike, Length, Truncate};
+
 /// Provides a common interface between [`TaggedFile`] and [`BoundTaggedFile`]
 pub trait TaggedFileExt {
 	/// Returns the file's [`FileType`]

lofty/src/flac/mod.rs

@@ -17,10 +17,10 @@ use crate::ogg::tag::VorbisCommentsRef;
 use crate::ogg::{OggPictureStorage, VorbisComments};
 use crate::picture::{Picture, PictureInformation};
 use crate::tag::TagExt;
-use crate::util::io::{FileLike, Length, Truncate};
 
 use std::borrow::Cow;
 
+use aud_io::io::{FileLike, Length, Truncate};
 use lofty_attr::LoftyFile;
 
 // Exports

lofty/src/flac/write.rs

@@ -7,11 +7,11 @@ use crate::ogg::tag::VorbisCommentsRef;
 use crate::ogg::write::create_comments;
 use crate::picture::{Picture, PictureInformation};
 use crate::tag::{Tag, TagType};
-use crate::util::io::{FileLike, Length, Truncate};
 
 use std::borrow::Cow;
 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
 
+use aud_io::io::{FileLike, Length, Truncate};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 
 const BLOCK_HEADER_SIZE: usize = 4;