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
159
160
161
162
163
164
165
166

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct UnknownFileType;

impl core::fmt::Display for UnknownFileType {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str("unknown file type")
  }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct InvalidNumericRange;

impl core::fmt::Display for InvalidNumericRange {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str("numeric range is invalid")
  }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DigitsParseError;

impl core::fmt::Display for DigitsParseError {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str("failed to parse digits")
  }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DataTypeParseError;

impl core::fmt::Display for DataTypeParseError {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str("failed to parse data type")
  }
}

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

/// Represents an error when parsing a timestamp.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TimeStampParseError {
  kind: TimestampParseErrorKind,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FlagParseError;

impl core::fmt::Display for FlagParseError {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str("failed to parse flag")
  }
}

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

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

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

/// Kinds of errors that can occur while parsing a timestamp.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TimestampParseErrorKind {
  /// The timestamp has an invalid length.
  InvalidLength,
  /// A character in the timestamp is not valid.
  InvalidCharacter,
  /// The minute value is invalid.
  InvalidMinute,
  /// The second value is invalid.
  InvalidSecond,
  /// The frame value is invalid.
  InvalidFrame,
}

impl core::fmt::Display for TimestampParseErrorKind {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    match self {
      TimestampParseErrorKind::InvalidLength => f.write_str("timestamp length is incorrect"),
      TimestampParseErrorKind::InvalidCharacter => {
        f.write_str("timestamp contains invalid character")
      }
      TimestampParseErrorKind::InvalidMinute => f.write_str("timestamp minute is invalid"),
      TimestampParseErrorKind::InvalidSecond => f.write_str("timestamp second is invalid"),
      TimestampParseErrorKind::InvalidFrame => f.write_str("timestamp frame is invalid"),
    }
  }
}

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

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

/// Represents an error when parsing a cue string.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CueStrError {
  kind: CueStrErrorKind,
}

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

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

/// Kinds of errors that can occur while parsing a cue string.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CueStrErrorKind {
  /// Missing opening or closing quotes.
  MissingQuotes,
  /// Missing ending double quote.
  MissingEndingQuote,
  /// An unescaped special character was found.
  UnescapedSpecialChar,
  /// Str is not a valid UTF-8.
  InvalidUtf8,
}

impl From<CueStrErrorKind> for CueStrError {
  #[inline]
  fn from(value: CueStrErrorKind) -> Self {
    Self::new(value)
  }
}

impl core::fmt::Display for CueStrErrorKind {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    match self {
      Self::InvalidUtf8 => f.write_str("string is not a valid utf-8"),
      Self::MissingQuotes => f.write_str("string needs to be quoted"),
      Self::MissingEndingQuote => f.write_str("string is missing ending double quote"),
      Self::UnescapedSpecialChar => f.write_str("unescaped special character found"),
    }
  }
}

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

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