aud_io: Move alloc utils from lofty

Author: Serial-ATA

lofty/src/util/alloc.rs aud_io/src/alloc.rslofty/src/util/alloc.rs renamed to aud_io/src/alloc.rs

@@ -1,12 +1,11 @@
 use crate::error::Result;
-use crate::macros::err;
-
+use crate::err;
 use crate::config::global_options;
 
-/// Provides the `fallible_repeat` method on `Vec`
+/// Provides the `fallible_repeat` method on [`Vec`]
 ///
-/// It is intended to be used in [`try_vec!`](crate::macros::try_vec).
-trait VecFallibleRepeat<T>: Sized {
+/// It is intended to be used in [`try_vec!`](crate::try_vec).
+pub trait VecFallibleRepeat<T>: Sized {
 	fn fallible_repeat(self, element: T, expected_size: usize) -> Result<Self>
 	where
 		T: Clone;
@@ -46,23 +45,24 @@ impl<T> VecFallibleRepeat<T> for Vec<T> {
 
 /// **DO NOT USE DIRECTLY**
 ///
-/// Creates a `Vec` of the specified length, containing copies of `element`.
+/// Creates a [`Vec`] of the specified length, containing copies of `element`.
 ///
-/// This should be used through [`try_vec!`](crate::macros::try_vec)
-pub(crate) fn fallible_vec_from_element<T>(element: T, expected_size: usize) -> Result<Vec<T>>
+/// This should be used through [`try_vec!`](crate::try_vec)
+#[doc(hidden)]
+pub fn fallible_vec_from_element<T>(element: T, expected_size: usize) -> Result<Vec<T>>
 where
 	T: Clone,
 {
 	Vec::new().fallible_repeat(element, expected_size)
 }
 
-/// Provides the `try_with_capacity` method on `Vec`
+/// Provides the `try_with_capacity` method on [`Vec`]
 ///
 /// This can be used directly.
-pub(crate) trait VecFallibleCapacity<T>: Sized {
-	/// Same as `Vec::with_capacity`, but takes `GlobalOptions::allocation_limit` into account.
+pub trait VecFallibleCapacity<T>: Sized {
+	/// Same as [`Vec::with_capacity()`], but takes [`GlobalOptions::allocation_limit()`] into account.
 	///
-	/// Named `try_with_capacity_stable` to avoid conflicts with the nightly `Vec::try_with_capacity`.
+	/// Named `try_with_capacity_stable` to avoid conflicts with the nightly [`Vec::try_with_capacity()`].
 	fn try_with_capacity_stable(capacity: usize) -> Result<Self>;
 }
 
@@ -81,7 +81,7 @@ impl<T> VecFallibleCapacity<T> for Vec<T> {
 
 #[cfg(test)]
 mod tests {
-	use crate::util::alloc::fallible_vec_from_element;
+	use super::fallible_vec_from_element;
 
 	#[test_log::test]
 	fn vec_fallible_repeat() {

aud_io/src/error.rs

@@ -5,6 +5,10 @@ pub type Result<T> = std::result::Result<T, AudioError>;
 
 #[derive(Debug)]
 pub enum AudioError {
+	// File data related errors
+	/// Attempting to read/write an abnormally large amount of data
+	TooMuchData,
+
 	/// Errors that arise while decoding text
 	TextDecode(&'static str),
 
@@ -15,6 +19,8 @@ pub enum AudioError {
 	StringFromUtf8(std::string::FromUtf8Error),
 	/// Unable to convert bytes to a str
 	StrFromUtf8(std::str::Utf8Error),
+	/// Failure to allocate enough memory
+	Alloc(std::collections::TryReserveError),
 	/// This should **never** be encountered
 	Infallible(std::convert::Infallible),
 }
@@ -37,6 +43,12 @@ impl From<std::str::Utf8Error> for AudioError {
 	}
 }
 
+impl From<std::collections::TryReserveError> for AudioError {
+	fn from(input: std::collections::TryReserveError) -> Self {
+		AudioError::Alloc(input)
+	}
+}
+
 impl From<std::convert::Infallible> for AudioError {
 	fn from(input: std::convert::Infallible) -> Self {
 		AudioError::Infallible(input)
@@ -46,12 +58,20 @@ impl From<std::convert::Infallible> for AudioError {
 impl Display for AudioError {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
+			AudioError::TextDecode(message) => write!(f, "Text decoding: {message}"),
+			
 			// Conversions
 			AudioError::StringFromUtf8(err) => write!(f, "{err}"),
 			AudioError::StrFromUtf8(err) => write!(f, "{err}"),
 			AudioError::Io(err) => write!(f, "{err}"),
-			AudioError::TextDecode(message) => write!(f, "Text decoding: {message}"),
+			AudioError::Alloc(err) => write!(f, "{err}"),
 			AudioError::Infallible(_) => write!(f, "An expected condition was not upheld"),
+
+			// Files
+			AudioError::TooMuchData => write!(
+				f,
+				"Attempted to read/write an abnormally large amount of data"
+			),
 		}
 	}
 }

aud_io/src/lib.rs

@@ -4,3 +4,4 @@ pub(crate) mod macros;
 pub mod math;
 pub mod io;
 pub mod config;
+pub mod alloc;

lofty/src/error.rs

@@ -7,7 +7,6 @@ use crate::file::FileType;
 use crate::id3::v2::FrameId;
 use crate::tag::ItemKey;
 
-use std::collections::TryReserveError;
 use std::fmt::{Debug, Display, Formatter};
 
 use ogg_pager::PageError;
@@ -68,8 +67,6 @@ pub enum ErrorKind {
 	Io(std::io::Error),
 	/// Represents all cases of [`std::fmt::Error`].
 	Fmt(std::fmt::Error),
-	/// Failure to allocate enough memory
-	Alloc(TryReserveError),
 }
 
 /// The types of errors that can occur while interacting with ID3v2 tags
@@ -493,14 +490,6 @@ impl From<std::fmt::Error> for LoftyError {
 	}
 }
 
-impl From<std::collections::TryReserveError> for LoftyError {
-	fn from(input: TryReserveError) -> Self {
-		Self {
-			kind: ErrorKind::Alloc(input),
-		}
-	}
-}
-
 impl From<std::convert::Infallible> for LoftyError {
 	fn from(input: std::convert::Infallible) -> Self {
 		Self {
@@ -517,7 +506,6 @@ impl Display for LoftyError {
 			ErrorKind::AudioIo(ref err) => write!(f, "{err}"),
 			ErrorKind::Io(ref err) => write!(f, "{err}"),
 			ErrorKind::Fmt(ref err) => write!(f, "{err}"),
-			ErrorKind::Alloc(ref err) => write!(f, "{err}"),
 
 			ErrorKind::UnknownFormat => {
 				write!(f, "No format could be determined from the provided file")

lofty/src/id3/v2/items/popularimeter.rs

@@ -1,11 +1,11 @@
 use crate::error::Result;
 use crate::id3::v2::{FrameFlags, FrameHeader, FrameId};
-use crate::util::alloc::VecFallibleCapacity;
 
 use std::borrow::Cow;
 use std::hash::{Hash, Hasher};
 use std::io::Read;
 
+use aud_io::alloc::VecFallibleCapacity;
 use aud_io::text::{TextDecodeOptions, TextEncoding, decode_text, encode_text};
 use byteorder::ReadBytesExt;
 

lofty/src/id3/v2/items/private_frame.rs

@@ -1,10 +1,10 @@
 use crate::error::Result;
 use crate::id3::v2::{FrameFlags, FrameHeader, FrameId};
-use crate::util::alloc::VecFallibleCapacity;
 
 use std::borrow::Cow;
 use std::io::Read;
 
+use aud_io::alloc::VecFallibleCapacity;
 use aud_io::text::{TextDecodeOptions, TextEncoding, decode_text, encode_text};
 
 const FRAME_ID: FrameId<'static> = FrameId::Valid(Cow::Borrowed("PRIV"));

lofty/src/macros.rs

@@ -1,5 +1,5 @@
 macro_rules! try_vec {
-	($elem:expr; $size:expr) => {{ $crate::util::alloc::fallible_vec_from_element($elem, $size)? }};
+	($elem:expr; $size:expr) => {{ aud_io::alloc::fallible_vec_from_element($elem, $size)? }};
 }
 
 // Shorthand for return Err(LoftyError::new(ErrorKind::Foo))

lofty/src/mp4/ilst/write.rs

@@ -10,12 +10,12 @@ use crate::mp4::ilst::r#ref::AtomRef;
 use crate::mp4::read::{AtomReader, atom_tree, find_child_atom, meta_is_full, verify_mp4};
 use crate::mp4::write::{AtomWriter, AtomWriterCompanion, ContextualAtom};
 use crate::picture::{MimeType, Picture};
-use crate::util::alloc::VecFallibleCapacity;
 
 use std::io::{Cursor, Seek, SeekFrom, Write};
 
 use aud_io::io::{FileLike, Length, Truncate};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use aud_io::alloc::VecFallibleCapacity;
 
 // A "full" atom is a traditional length + identifier, followed by a version (1) and flags (3)
 const FULL_ATOM_SIZE: u64 = ATOM_HEADER_LEN + 4;

lofty/src/mp4/properties.rs

@@ -4,11 +4,11 @@ use crate::config::ParsingMode;
 use crate::error::{LoftyError, Result};
 use crate::macros::{decode_err, err, try_vec};
 use crate::properties::FileProperties;
-use crate::util::alloc::VecFallibleCapacity;
 
 use std::io::{Cursor, Read, Seek, SeekFrom};
 use std::time::Duration;
 
+use aud_io::alloc::VecFallibleCapacity;
 use aud_io::math::RoundedDivision;
 use byteorder::{BigEndian, ReadBytesExt};
 

lofty/src/util/mod.rs

@@ -1,4 +1,3 @@
-pub(crate) mod alloc;
 pub(crate) mod io;
 
 pub(crate) fn flag_item(item: &str) -> Option<bool> {