cue_lib 0.1.0

cuesheet library
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#[cfg(feature = "ean")]
pub use ean_error::*;

#[cfg(feature = "upc")]
pub use upc_error::*;

/// Represents an error when parsing an ISRC string.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct IsrcParseError {
  kind: IsrcParseErrorKind,
}

impl IsrcParseError {
  #[inline]
  pub const fn new(kind: IsrcParseErrorKind) -> Self {
    Self { kind }
  }

  #[inline]
  pub const fn kind(&self) -> IsrcParseErrorKind {
    self.kind
  }
}

/// Kinds of errors that can occur while parsing an ISRC string.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum IsrcParseErrorKind {
  /// The ISRC string has an invalid length.
  InvalidLength,
  /// The ISRC string has an invalid owner code.
  InvalidOwner,
  /// The ISRC string has an invalid country code.
  InvalidCountryCode,
  /// The ISRC string has an invalid serial number.
  InvalidSerial,
  /// The ISRC string has an invalid year.
  InvalidYear,
}

impl core::fmt::Display for IsrcParseErrorKind {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    match self {
      IsrcParseErrorKind::InvalidLength => f.write_str("ISRC string has invalid length"),
      IsrcParseErrorKind::InvalidOwner => f.write_str("ISRC string has invalid owner code"),
      IsrcParseErrorKind::InvalidCountryCode => f.write_str("ISRC string has invalid country code"),
      IsrcParseErrorKind::InvalidSerial => f.write_str("ISRC string has invalid serial number"),
      IsrcParseErrorKind::InvalidYear => f.write_str("ISRC string has invalid year"),
    }
  }
}

impl core::fmt::Display for IsrcParseError {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_fmt(format_args!("invalid ISRC string: {}", self.kind))
  }
}

impl core::error::Error for IsrcParseError {}

#[cfg(feature = "ean")]
mod ean_error {
  /// Represents an error when parsing an EAN string.
  #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  pub struct EanParseError {
    kind: EanParseErrorKind,
  }

  impl EanParseError {
    #[inline]
    pub const fn new(kind: EanParseErrorKind) -> Self {
      Self { kind }
    }

    #[inline]
    pub const fn kind(&self) -> EanParseErrorKind {
      self.kind
    }
  }

  /// Kinds of errors that can occur while parsing an EAN string.
  #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  pub enum EanParseErrorKind {
    /// The EAN string contains an invalid character.
    InvalidCharacter,
    /// The EAN string has an invalid length.
    InvalidLength,
    /// The EAN string failed checksum validation.
    ChecksumFail,
  }

  impl core::fmt::Display for EanParseErrorKind {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
      match self {
        EanParseErrorKind::InvalidCharacter => f.write_str("EAN string contains invalid character"),
        EanParseErrorKind::InvalidLength => f.write_str("EAN string has invalid length"),
        EanParseErrorKind::ChecksumFail => f.write_str("EAN string failed checksum validation"),
      }
    }
  }

  impl core::fmt::Display for EanParseError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
      f.write_fmt(format_args!("invalid EAN string: {}", self.kind))
    }
  }

  impl core::error::Error for EanParseError {}
}

#[cfg(feature = "upc")]
mod upc_error {
  /// Represents an error when parsing a UPC string.
  #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  pub struct UpcParseError {
    kind: UpcParseErrorKind,
  }

  impl UpcParseError {
    #[inline]
    pub const fn new(kind: UpcParseErrorKind) -> Self {
      Self { kind }
    }

    #[inline]
    pub const fn kind(&self) -> UpcParseErrorKind {
      self.kind
    }
  }

  /// Kinds of errors that can occur while parsing a UPC string.
  #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  pub enum UpcParseErrorKind {
    /// The UPC string contains an invalid character.
    InvalidCharacter,
    /// The UPC string has an invalid length.
    InvalidLength,
    /// The UPC string failed checksum validation.
    ChecksumFail,
  }

  impl core::fmt::Display for UpcParseErrorKind {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
      match self {
        UpcParseErrorKind::InvalidCharacter => f.write_str("UPC string contains invalid character"),
        UpcParseErrorKind::InvalidLength => f.write_str("UPC string has invalid length"),
        UpcParseErrorKind::ChecksumFail => f.write_str("UPC string failed checksum validation"),
      }
    }
  }

  impl core::fmt::Display for UpcParseError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
      f.write_fmt(format_args!("invalid UPC string: {}", self.kind))
    }
  }

  impl core::error::Error for UpcParseError {}
}