version: bump to 0.5.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bdat"
-version = "0.5.0-alpha.1"
+version = "0.5.0"
 description = "(De)serialization library for Monolithsoft's BDAT file format"
 authors = ["RoccoDev <[email protected]>"]
 edition = "2021"
@@ -12,7 +12,7 @@ exclude = ["/.vscode", "/.github"]
 
 [dependencies]
 serde = { version = "1.0", optional = true, features = ["derive"] }
-byteorder = "1.4"
+byteorder = "1.5"
 thiserror = "1.0"
 enum-kinds = "0.5.1"
 num_enum = "0.7.2"

src/io/detect.rs

@@ -10,12 +10,14 @@ use crate::legacy::read::{LegacyBytes, LegacyReader};
 use crate::modern::FileReader;
 use crate::{BdatVersion, LegacyVersion, SwitchEndian, WiiEndian};
 
+/// Compatibility file reader returned by [`bdat::from_reader`](`crate::from_reader`)
 pub enum VersionReader<R: Read + Seek> {
     LegacyWii(LegacyReader<R, WiiEndian>),
     LegacySwitch(LegacyReader<R, SwitchEndian>),
     Modern(FileReader<BdatReader<R, SwitchEndian>, SwitchEndian>),
 }
 
+/// Compatibility slice reader returned by [`bdat::from_bytes`](`crate::from_bytes`)
 pub enum VersionSlice<'b> {
     LegacyWii(LegacyBytes<'b, WiiEndian>),
     LegacySwitch(LegacyBytes<'b, SwitchEndian>),

src/io/read.rs

@@ -20,15 +20,15 @@ pub struct BdatSlice<'b, E> {
     _endianness: PhantomData<E>,
 }
 
+/// Table extractor from a BDAT file.
+///
+/// ## Notice
+/// In future versions, this may be replaced by a common file struct.
 pub trait BdatFile<'b> {
     /// The output table type
     type TableOut;
 
     /// Reads all tables from the BDAT source.
-    ///
-    /// ## Future compatibility
-    /// This function might start returning an iterator when Rust 1.75.0
-    /// hits stable (specifically [this issue](https://github.com/rust-lang/rust/issues/91611)).
     fn get_tables(&mut self) -> Result<Vec<Self::TableOut>>;
 
     /// Returns the number of tables in the BDAT file.

src/table/cell.rs

@@ -71,6 +71,7 @@ pub enum Cell<'b> {
     ValueType,
     derive(TryFromPrimitive),
     repr(u8),
+    doc = "Discriminants for [`Value`], generated automatically.",
     cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize)),
     cfg_attr(feature = "serde", serde(into = "u8", try_from = "u8"))
 )]

src/table/compat.rs

@@ -448,6 +448,10 @@ impl<'t, 'buf> CompatColumnRef<'t, 'buf> {
 }
 
 impl<'b> CompatRow<'b> {
+    /// Returns an iterator over this row's cells.
+    ///
+    /// Because this is a compatibility wrapper, the returned [`Cell`]s must be owned
+    /// (and therefore cloned), as modern tables do not store cells directly.
     pub fn cells(&self) -> impl Iterator<Item = Cell<'b>> + '_ {
         match self {
             CompatRow::Modern(m) => {
@@ -457,6 +461,10 @@ impl<'b> CompatRow<'b> {
         }
     }
 
+    /// Returns an iterator over this row's cells, taking ownership of the row.
+    ///
+    /// Unlike the [borrowed variant](CompatRow::cells), this iterator moves instead of cloning.
+    /// In the case of modern tables, the moved value is wrapped.
     pub fn into_cells(self) -> impl Iterator<Item = Cell<'b>> {
         match self {
             CompatRow::Modern(m) => CompatIter::Modern(m.into_values().map(Cell::Single)),

toolset/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "bdat-toolset"
 authors = ["RoccoDev <[email protected]>"]
-version = "0.5.0-alpha"
+version = "0.5.0"
 edition = "2021"
 license = "gpl-3.0"