ot_tools_io/

traits.rs

/*
SPDX-License-Identifier: GPL-3.0-or-later
Copyright © 2024 Mike Robeson [dijksterhuis]
*/

use crate::OtToolsIoError;
use serde::{Deserialize, Serialize};
use std::fmt::Debug;
use std::path::Path;

/// Convenience trait for types which directly correspond to Elektron Octatrack binary data files.
/// Associated functions and methods etc. for File I/O, plus a `repr` method for debugging.
pub trait OctatrackFileIO: Serialize + for<'a> Deserialize<'a> {
    /// Read type from an Octatrack data file at path
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data").join("blank-project").join("bank01.work");
    /// use ot_tools_io::{BankFile, OctatrackFileIO};
    /// // no newlines
    /// BankFile::from_data_file(&path).unwrap().repr(None);
    /// // no newlines
    /// BankFile::from_data_file(&path).unwrap().repr(Some(false));
    /// // with newlines
    /// BankFile::from_data_file(&path).unwrap().repr(Some(true));
    /// ```
    fn repr(&self, newlines: Option<bool>)
    where
        Self: Debug,
    {
        if newlines.unwrap_or(true) {
            println!("{self:#?}")
        } else {
            println!("{self:?}")
        };
    }
    // BYTES
    /// Read type from an Octatrack data file at path
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data").join("blank-project").join("bank01.work");
    /// use ot_tools_io::{BankFile, OctatrackFileIO};
    /// let bank = BankFile::from_data_file(&path).unwrap();
    /// assert_eq!(bank.datatype_version, 23);
    /// ```
    fn from_data_file(path: &Path) -> Result<Self, OtToolsIoError> {
        let bytes = crate::read_bin_file(path)?;
        let data = Self::from_bytes(&bytes)?;
        Ok(data)
    }
    /// Read type from bytes
    /// ```rust
    /// // need to create everything from scratch in this example as many bytes otherwise
    /// use serde::{Deserialize, Serialize};
    /// use ot_tools_io::{OctatrackFileIO, OtToolsIoError};
    ///
    /// #[derive(Serialize, Deserialize, Debug, PartialEq)]
    /// struct Something {
    ///     value: u8,
    /// }
    ///
    /// impl OctatrackFileIO for Something {}
    ///
    /// let x = [10];
    ///
    /// let r = Something::from_bytes(&x);
    /// assert!(r.is_ok());
    /// assert_eq!(r.unwrap(), Something { value: 10});
    /// ```
    fn from_bytes(bytes: &[u8]) -> Result<Self, OtToolsIoError> {
        let x = Self::decode(bytes)?;
        Ok(x)
    }
    /// Write type to an Octatrack data file at path
    /// ```rust
    /// # use std::{path::PathBuf, fs::create_dir_all, env::temp_dir};
    /// # let path = temp_dir()
    /// #    .join("ot-tools-io")
    /// #    .join("doctest")
    /// #    .join("to_bytes_file.bank.work");
    /// # create_dir_all(&path.parent().unwrap()).unwrap();
    /// #
    /// use ot_tools_io::{OctatrackFileIO, BankFile};
    /// let r = BankFile::default().to_data_file(&path);
    /// assert!(r.is_ok());
    /// assert!(path.exists());
    /// ```
    fn to_data_file(&self, path: &Path) -> Result<(), OtToolsIoError> {
        let bytes = Self::to_bytes(self)?;
        crate::write_bin_file(&bytes, path)?;
        Ok(())
    }
    /// Create bytes from type
    /// ```rust
    /// // need to create everything from scratch in this example as many bytes otherwise
    /// use serde::{Deserialize, Serialize};
    /// use ot_tools_io::OctatrackFileIO;
    ///
    /// #[derive(Serialize, Deserialize, Debug, PartialEq)]
    /// struct Something {
    ///     value: u8,
    /// }
    ///
    /// impl OctatrackFileIO for Something {}
    ///
    /// let x = Something { value: 10 };
    /// let r = x.to_bytes();
    /// assert!(r.is_ok());
    /// assert_eq!(r.unwrap(), [10]);
    /// ```
    fn to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError> {
        self.encode()
    }
    // YAML
    /// Read type from a YAML file at path
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data").join("projects").join("default.yaml");
    /// use ot_tools_io::{ProjectFile, OctatrackFileIO};
    /// let project = ProjectFile::from_yaml_file(&path).unwrap();
    /// assert_eq!(project.metadata.project_version, 19);
    /// ```
    fn from_yaml_file(path: &Path) -> Result<Self, OtToolsIoError> {
        let string = crate::read_str_file(path)?;
        let data = Self::from_yaml_str(&string)?;
        Ok(data)
    }
    /// Read type from YAML string
    /// ```rust
    /// // need to create everything from scratch in this example
    /// use serde::{Deserialize, Serialize};
    /// use ot_tools_io::OctatrackFileIO;
    ///
    /// #[derive(Serialize, Deserialize, Debug, PartialEq)]
    /// struct Something {
    ///     value: u8,
    /// }
    ///
    /// impl OctatrackFileIO for Something {}
    ///
    /// let r = Something::from_yaml_str("value: 10\n");
    /// assert!(r.is_ok());
    /// assert_eq!(r.unwrap(), Something { value: 10 });
    /// ```
    fn from_yaml_str(yaml: &str) -> Result<Self, OtToolsIoError> {
        let x = serde_yml::from_str(yaml)?;
        Ok(x)
    }
    /// Write type to a YAML file at path
    /// ```rust
    /// # use std::{path::PathBuf, fs::create_dir_all, env::temp_dir};
    /// # let path = temp_dir()
    /// #    .join("ot-tools-io")
    /// #    .join("doctest")
    /// #    .join("to_bytes_file.bank.yaml");
    /// # create_dir_all(&path.parent().unwrap()).unwrap();
    /// #
    /// use ot_tools_io::{OctatrackFileIO, BankFile};
    /// let r = BankFile::default().to_yaml_file(&path);
    /// assert!(r.is_ok());
    /// assert!(path.exists());
    /// ```
    fn to_yaml_file(&self, path: &Path) -> Result<(), OtToolsIoError> {
        let yaml = Self::to_yaml_string(self)?;
        crate::write_str_file(&yaml, path)?;
        Ok(())
    }
    /// Create YAML string from type
    /// ```rust
    /// use ot_tools_io::{BankFile, OctatrackFileIO};
    /// let bank = BankFile::default().to_yaml_string().unwrap();
    /// assert_eq!(bank.len(), 12532024);
    /// assert_eq!(bank[0..15], "header:\n- 70\n- ".to_string());
    /// ```
    fn to_yaml_string(&self) -> Result<String, OtToolsIoError> {
        Ok(serde_yml::to_string(self)?)
    }
    // JSON
    /// Read type from a JSON file at path
    fn from_json_file(path: &Path) -> Result<Self, OtToolsIoError> {
        let string = crate::read_str_file(path)?;
        let data = Self::from_yaml_str(&string)?;
        Ok(data)
    }
    /// Create type from JSON string
    /// ```rust
    /// // need to create everything from scratch in this example
    /// use serde::{Deserialize, Serialize};
    /// use ot_tools_io::OctatrackFileIO;
    ///
    /// #[derive(Serialize, Deserialize, Debug, PartialEq)]
    /// struct Something {
    ///     value: u8,
    /// }
    ///
    /// impl OctatrackFileIO for Something {}
    ///
    /// let r = Something::from_json_str("{\"value\":10}");
    /// assert!(r.is_ok());
    /// assert_eq!(r.unwrap(), Something { value: 10 });
    /// ```
    fn from_json_str(json: &str) -> Result<Self, OtToolsIoError> {
        Ok(serde_json::from_str::<Self>(json)?)
    }
    /// Write type to a JSON file at path
    /// ```rust
    /// # use std::{path::PathBuf, fs::create_dir_all, env::temp_dir};
    /// # let path = temp_dir()
    /// #    .join("ot-tools-io")
    /// #    .join("doctest")
    /// #    .join("to_bytes_file.bank.json");
    /// # create_dir_all(&path.parent().unwrap()).unwrap();
    /// #
    /// use ot_tools_io::{OctatrackFileIO, BankFile};
    /// let r = BankFile::default().to_json_file(&path);
    /// assert!(r.is_ok());
    /// assert!(path.exists());
    /// ```
    fn to_json_file(&self, path: &Path) -> Result<(), OtToolsIoError> {
        let yaml = Self::to_json_string(self)?;
        crate::write_str_file(&yaml, path)?;
        Ok(())
    }
    /// Create JSON string from type
    /// ```rust
    /// use ot_tools_io::{BankFile, OctatrackFileIO};
    /// let json = BankFile::default().to_json_string().unwrap();
    /// assert_eq!(json.len(), 7761363);
    /// assert_eq!(json[0..15], "{\"header\":[70,7".to_string());
    /// ```
    fn to_json_string(&self) -> Result<String, OtToolsIoError> {
        Ok(serde_json::to_string(&self)?)
    }

    /// Adds serialization via [`bincode`] and [`serde`] to a type. Must be present on all major file
    /// types.
    ///
    /// ```
    /// use std::error::Error;
    /// use ot_tools_io::OctatrackFileIO;
    ///
    /// #[derive(serde::Deserialize, serde::Serialize, std::fmt::Debug)]
    /// struct SomeType {
    ///     x: u8,
    ///     y: u32,
    /// }
    ///
    /// // default implementation
    /// impl OctatrackFileIO for SomeType {}
    ///
    /// let x = SomeType { x : 8, y: 32857983 };
    /// let encoded = x.encode().unwrap();
    /// assert_eq!(
    ///     vec![8, 127, 95, 245, 1],
    ///     encoded,
    /// );
    /// ```
    fn encode(&self) -> Result<Vec<u8>, OtToolsIoError>
    where
        Self: Serialize,
    {
        Ok(bincode::serialize(&self)?)
    }

    /// Deserialization via [`bincode`] and [`serde`].
    /// ```
    /// use std::error::Error;
    /// use ot_tools_io::{OctatrackFileIO, OtToolsIoError};
    ///
    /// #[derive(serde::Deserialize, serde::Serialize, std::fmt::Debug, PartialEq)]
    /// struct SomeType {
    ///     x: u8,
    ///     y: u32,
    /// }
    ///
    /// // default implementation
    /// impl OctatrackFileIO for SomeType {}
    ///
    /// let bytes: Vec<u8> = vec![8, 127, 95, 245, 1];
    /// let decoded = SomeType::decode(&bytes).unwrap();
    ///
    /// assert_eq!(
    ///     SomeType { x : 8, y: 32857983 },
    ///     decoded,
    /// );
    /// ```
    fn decode(bytes: &[u8]) -> Result<Self, OtToolsIoError>
    where
        Self: Sized,
        Self: for<'a> Deserialize<'a>,
    {
        bincode::deserialize::<Self>(bytes).map_err(|e| e.into())
    }
}

/// Trait for adding a method which swaps the bytes on all fields of a struct.
///
/// Useful for handling file writes to a different endianness.
// ```
// use ot_tools_io::SwapBytes;
//
// #[derive(std::fmt::Debug, PartialEq)]
// struct SomeType {
//     x: u8,
//     y: u32,
// }
//
// impl SwapBytes for SomeType {
//     fn swap_bytes(self) -> Self {
//         Self {
//             x: self.x.swap_bytes(),
//             y: self.y.swap_bytes(),
//         }
//     }
// }
//
// let x = SomeType { x : 8, y: 32857983 };
// let swapped = x.swap_bytes();
// assert_eq!(
//     SomeType { x: 8_u8.swap_bytes(), y: 32857983_u32.swap_bytes()},
//     swapped,
// );
// ```
pub(crate) trait SwapBytes {
    fn swap_bytes(self) -> Self
    where
        Self: Sized;
}

/// Create a 'default' container type `T` with `N` instances of `Self`.
/// Used when we need a collection of default type instances
/// e.g. when creating a default bank we need 16 default patterns.
///
/// Using the `ot_tools_io_derive::DefaultsAsArray, DefaultsAsArrayBoxed` proc_macro will automatically derive
/// implementations for
/// * `T: [Self; N]`
/// * `T: Box<serde_big_array::Array<Self, N>>`
///
/// If you need to handle incrementing id fields, see the existing examples for the following types
/// * [`crate::patterns::AudioTrackTrigs`],
/// * [`crate::patterns::MidiTrackTrigs`],
/// * [`crate::parts::Part`]
/// * [`crate::parts::AudioTrackMachineSlot`]
///
/// ```
/// use std::array::from_fn;
/// use serde_big_array::Array;
/// use ot_tools_io::Defaults;
///
/// struct SomeType {
///     x: u8,
/// }
///
/// impl Default for SomeType {
///     fn default() -> Self {
///         Self { x: 0 }
///     }
/// }
///
/// impl<const N: usize> Defaults<[SomeType; N]> for SomeType {
///     fn defaults() -> [Self; N] where Self: Default {
///         from_fn(|_| Self::default())
///     }
/// }
///
/// impl<const N: usize> Defaults<Box<Array<SomeType, N>>> for SomeType {
///     fn defaults() -> Box<Array<Self, N>> where Self: Defaults<[Self; N]> {
///         Box::new(Array(
///             // use the [Self; N] impl to generate values
///             <Self as Defaults<[Self; N]>>::defaults()
///         ))
///     }
/// }
///
/// impl<const N: usize> Defaults<Array<SomeType, N>> for SomeType {
///     fn defaults() -> Array<Self, N> where Self: Defaults<[Self; N]> {
///         Array(
///             // use the [Self; N] impl to generate values
///             <Self as Defaults<[Self; N]>>::defaults()
///         )
///     }
/// }
///
/// let xs: [SomeType; 20] = SomeType::defaults();
/// assert_eq!(xs.len(), 20);
///
/// let xs: [SomeType; 25] = SomeType::defaults();
/// assert_eq!(xs.len(), 25);
///
/// let xs: Box<Array<SomeType, 20>> = SomeType::defaults();
/// assert_eq!(xs.len(), 20);
///
/// let xs: Box<Array<SomeType, 25>> = SomeType::defaults();
/// assert_eq!(xs.len(), 25);
///
/// let xs: Array<SomeType, 20> = SomeType::defaults();
/// assert_eq!(xs.len(), 20);
///
/// let xs: Array<SomeType, 25> = SomeType::defaults();
/// assert_eq!(xs.len(), 25);
/// ```
pub trait Defaults<T> {
    /// Create an default container type `T` containing `N` default instances of `Self`.
    fn defaults() -> T
    where
        Self: Default;
}

/// Adds a method to check the current data structure matches the default for the type
/// ```rust
/// use ot_tools_io::{IsDefault, BankFile};
///
/// let mut bank = BankFile::default();
/// assert_eq!(bank.is_default(), true);
///
/// bank.datatype_version = 190;
/// assert_eq!(bank.is_default(), false);
/// ```
pub trait IsDefault {
    fn is_default(&self) -> bool
    where
        Self: Default + PartialEq,
    {
        &Self::default() == self
    }
}

/// A type has a checksum field which needs implementations to handle calculation and validation
pub trait HasChecksumField {
    /// Method for calculating the checksum value for types that have a checksum field
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data")
    /// #     .join("blank-project")
    /// #     .join("bank01.work");
    /// use ot_tools_io::{HasChecksumField, OctatrackFileIO, BankFile};
    /// let bank = BankFile::from_data_file(&path).unwrap();
    /// assert_eq!(bank.checksum, bank.calculate_checksum().unwrap())
    /// ```
    fn calculate_checksum(&self) -> Result<u16, OtToolsIoError>;

    /// Method to verify if checksum is valid in some data type.
    /// [See this thread](https://www.elektronauts.com/t/bank-unavailable-octatrack/190647/27).
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data")
    /// #     .join("blank-project")
    /// #     .join("bank01.work");
    /// use ot_tools_io::{HasChecksumField, OctatrackFileIO, BankFile};
    /// // true for valid checksum values
    /// assert!(BankFile::from_data_file(&path).unwrap().check_checksum().unwrap())
    /// ```
    fn check_checksum(&self) -> Result<bool, OtToolsIoError>;
}

/// A type has a header field which needs implementations to handle validation
pub trait HasHeaderField {
    /// Method to verify if header(s) are valid in some data.
    /// [See this thread](https://www.elektronauts.com/t/bank-unavailable-octatrack/190647/27).
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data")
    /// #     .join("blank-project")
    /// #     .join("bank01.work");
    /// use ot_tools_io::{HasHeaderField, OctatrackFileIO, BankFile};
    /// assert!(BankFile::from_data_file(&path).unwrap().check_header().unwrap()) // true for valid header values
    /// ```
    // NOTE: ot-tools-io does not validate headers on file read, which means it is
    // possible to perform checks like this when a data file has been read.
    // otherwise we'd have to do a complicated check to verify headers on every
    // file we read, then throw out an error and probably do some complicated
    // file (bad header, which patterns, which track within patterns etc.).
    fn check_header(&self) -> Result<bool, OtToolsIoError>;
}

/// A type has a file patch version field which needs implementations to handle validation
pub trait HasFileVersionField {
    /// Method to verify if the data file version field is valid for the given type.
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data")
    /// #     .join("blank-project")
    /// #     .join("bank01.work");
    /// use ot_tools_io::{HasFileVersionField, OctatrackFileIO, BankFile};
    /// // true for valid version values
    /// assert!(BankFile::from_data_file(&path).unwrap().check_file_version().unwrap())
    /// ```
    // NOTE: ot-tools-io does not validate headers on file read, which means it is
    // possible to perform checks like this when a data file has been read.
    // otherwise we'd have to do a complicated check to verify headers on every
    // file we read, then throw out an error and probably do some complicated
    // error handling to explain to the end user exactly why we couldn't load the
    // file (bad header, which patterns, which track within patterns etc.).
    fn check_file_version(&self) -> Result<bool, OtToolsIoError>;
}

/// Adds a single method using the [`HasHeaderField::check_header`],
/// [`HasChecksumField::check_checksum`] and [`HasFileVersionField::check_file_version`]
/// methods to run a full integrity check.
pub trait CheckFileIntegrity: HasHeaderField + HasChecksumField + HasFileVersionField {
    /// ```rust
    /// # use std::path::PathBuf;
    /// # let path = PathBuf::from("test-data")
    /// #     .join("blank-project")
    /// #     .join("bank01.work");
    /// use ot_tools_io::{CheckFileIntegrity, OctatrackFileIO, BankFile};
    /// // true for valid checksum+header values
    /// assert!(BankFile::from_data_file(&path).unwrap().check_integrity().unwrap())
    /// ```
    fn check_integrity(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.check_header()? && self.check_checksum()? && self.check_file_version()?)
    }
}