ass-core 0.1.2

High-performance ASS subtitle format parser and analyzer
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

//! Inherent constructors and introspection methods for `CoreError`.
//!
//! Provides convenience constructors plus helpers to classify errors by
//! recoverability, internal-bug status, and location information.

use super::CoreError;

use alloc::format;
use core::fmt;

#[cfg(not(feature = "std"))]
extern crate alloc;

impl CoreError {
    /// Create parse error from message
    pub fn parse<T: fmt::Display>(message: T) -> Self {
        Self::Parse(crate::parser::ParseError::IoError {
            message: format!("{message}"),
        })
    }

    /// Create internal error (indicates a bug)
    pub fn internal<T: fmt::Display>(message: T) -> Self {
        Self::Internal(format!("{message}"))
    }

    /// Check if error is recoverable
    #[must_use]
    pub const fn is_recoverable(&self) -> bool {
        match self {
            Self::Parse(parse_err) => !matches!(
                parse_err,
                crate::parser::ParseError::OutOfMemory { .. }
                    | crate::parser::ParseError::InputTooLarge { .. }
                    | crate::parser::ParseError::InternalError { .. }
            ),
            Self::Tokenization(_)
            | Self::InvalidColor(_)
            | Self::InvalidNumeric(_)
            | Self::InvalidTime(_)
            | Self::Validation(_)
            | Self::Analysis(_)
            | Self::Plugin(_)
            | Self::Utf8Error { .. }
            | Self::Io(_)
            | Self::Config(_)
            | Self::FeatureNotSupported { .. }
            | Self::VersionIncompatible { .. } => true,

            Self::OutOfMemory(_)
            | Self::ResourceLimitExceeded { .. }
            | Self::SecurityViolation(_)
            | Self::Internal(_) => false,
        }
    }

    /// Check if error indicates a bug in the library
    #[must_use]
    pub const fn is_internal_bug(&self) -> bool {
        matches!(self, Self::Internal(_))
    }

    /// Get the underlying parse error if this is a parse error
    #[must_use]
    pub const fn as_parse_error(&self) -> Option<&crate::parser::ParseError> {
        match self {
            Self::Parse(parse_err) => Some(parse_err),
            _ => None,
        }
    }

    /// Get line number for errors that have location information
    #[must_use]
    pub const fn line_number(&self) -> Option<usize> {
        match self {
            Self::Parse(
                crate::parser::ParseError::ExpectedSectionHeader { line }
                | crate::parser::ParseError::UnclosedSectionHeader { line }
                | crate::parser::ParseError::UnknownSection { line, .. }
                | crate::parser::ParseError::InvalidFieldFormat { line }
                | crate::parser::ParseError::InvalidFormatLine { line, .. }
                | crate::parser::ParseError::FieldCountMismatch { line, .. }
                | crate::parser::ParseError::InvalidTimeFormat { line, .. }
                | crate::parser::ParseError::InvalidColorFormat { line, .. }
                | crate::parser::ParseError::InvalidNumericValue { line, .. }
                | crate::parser::ParseError::InvalidStyleOverride { line, .. }
                | crate::parser::ParseError::InvalidDrawingCommand { line, .. }
                | crate::parser::ParseError::UuDecodeError { line, .. }
                | crate::parser::ParseError::MaxNestingDepth { line, .. }
                | crate::parser::ParseError::InternalError { line, .. },
            ) => Some(*line),
            Self::Utf8Error { position, .. } => Some(*position),
            _ => None,
        }
    }

    /// Check if this is a specific type of parse error
    #[must_use]
    pub fn is_parse_error_type(&self, error_type: &str) -> bool {
        match self {
            Self::Parse(parse_err) => matches!(
                (error_type, parse_err),
                (
                    "section_header",
                    crate::parser::ParseError::ExpectedSectionHeader { .. }
                ) | (
                    "unclosed_header",
                    crate::parser::ParseError::UnclosedSectionHeader { .. }
                ) | (
                    "unknown_section",
                    crate::parser::ParseError::UnknownSection { .. }
                ) | (
                    "field_format",
                    crate::parser::ParseError::InvalidFieldFormat { .. }
                        | crate::parser::ParseError::FieldCountMismatch { .. }
                ) | (
                    "time_format",
                    crate::parser::ParseError::InvalidTimeFormat { .. }
                ) | (
                    "color_format",
                    crate::parser::ParseError::InvalidColorFormat { .. }
                ) | (
                    "numeric_value",
                    crate::parser::ParseError::InvalidNumericValue { .. }
                ) | ("utf8", crate::parser::ParseError::Utf8Error { .. })
            ),
            _ => false,
        }
    }
}