caesura 0.22.3

An all-in-one command line tool to **transcode FLAC** audio files and **upload to gazelle** based indexers/trackers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use rogue_logging::Error;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt;
use std::fmt::{Debug, Display, Formatter};

const HEXADECIMAL_RADIX: u32 = 16;

/// Byte array hash
#[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
pub struct Hash<const N: usize> {
    bytes: [u8; N],
}

impl<const N: usize> Hash<N> {
    /// Create a new hash from a byte array
    pub fn new(bytes: [u8; N]) -> Self {
        Self { bytes }
    }

    /// Creates a hash from a hexadecimal string.
    pub fn from_string(hex: &str) -> Result<Self, Error> {
        let bytes = to_bytes(hex)?;
        Ok(Hash::new(bytes))
    }

    /// Get the hash as a hexadecimal string.
    pub fn to_hex(&self) -> String {
        self.bytes.iter().fold(String::new(), |mut acc, &b| {
            acc.push_str(&format!("{b:02x}"));
            acc
        })
    }

    /// Get the byte array
    pub fn as_bytes(&self) -> &[u8; N] {
        &self.bytes
    }

    /// Truncate the hash
    ///
    /// Returns `None` if `M` > `N`
    pub fn truncate<const M: usize>(&self) -> Option<Hash<M>> {
        let bytes: [u8; M] = self.bytes[..M].try_into().ok()?;
        Some(Hash::new(bytes))
    }
}

impl<const N: usize> Debug for Hash<N> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        write!(formatter, "{}", self.to_hex())
    }
}

impl<const N: usize> Default for Hash<N> {
    fn default() -> Self {
        Self::new([0; N])
    }
}

impl<const N: usize> Display for Hash<N> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        write!(formatter, "{}", self.to_hex())
    }
}

impl<const N: usize> Serialize for Hash<N> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.to_hex())
    }
}

impl<'de, const N: usize> Deserialize<'de> for Hash<N> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let hex_str = String::deserialize(deserializer)?;
        #[allow(clippy::absolute_paths)]
        Hash::from_string(&hex_str).map_err(serde::de::Error::custom)
    }
}

/// Convert a hexadecimal string to a 20-byte array.
#[allow(clippy::needless_range_loop)]
#[allow(clippy::indexing_slicing)]
fn to_bytes<const N: usize>(hex: &str) -> Result<[u8; N], Error> {
    let length = hex.len();
    if length != N * 2 {
        return Err(Error {
            action: "convert hash".to_owned(),
            message: format!("Length was not {}: {length}", N * 2),
            ..Error::default()
        });
    }
    let mut bytes = [0_u8; N];
    for i in 0..N {
        let start = i * 2;
        let byte_str = &hex[start..start + 2];
        bytes[i] = to_byte(byte_str)?;
    }
    Ok(bytes)
}

/// Convert a 2-character hexadecimal string to a byte.
fn to_byte(hex: &str) -> Result<u8, Error> {
    u8::from_str_radix(hex, HEXADECIMAL_RADIX).map_err(|_| Error {
        action: "convert hash".to_owned(),
        message: format!("Invalid hex character: {hex}"),
        ..Error::default()
    })
}