Enum CoreError

pub enum CoreError {
    Parse(ParseError),
    Tokenization(String),
    Analysis(String),
    Plugin(String),
    InvalidColor(String),
    InvalidNumeric(String),
    InvalidTime(String),
    Utf8Error {
        position: usize,
        message: String,
    },
    Io(String),
    OutOfMemory(String),
    Config(String),
    Validation(String),
    FeatureNotSupported {
        feature: String,
        required_feature: String,
    },
    VersionIncompatible {
        message: String,
    },
    ResourceLimitExceeded {
        resource: String,
        current: usize,
        limit: usize,
    },
    SecurityViolation(String),
    Internal(String),
}

Main error type for ASS-RS core operations

Wraps all error types from different modules to provide a unified error handling interface. Can be converted from module-specific errors.

Variants

Parse(ParseError)

Parsing errors from parser module

Tokenization(String)

Tokenization errors

Analysis(String)

Analysis errors

Plugin(String)

Plugin system errors

InvalidColor(String)

Color format parsing errors

InvalidNumeric(String)

Numeric value parsing errors

InvalidTime(String)

Time format parsing errors

Utf8Error

UTF-8 encoding errors

Fields

position: usize

message: String

Io(String)

File I/O errors

OutOfMemory(String)

Memory allocation errors

Config(String)

Configuration errors

Validation(String)

Validation errors

FeatureNotSupported

Feature not supported in current configuration

Fields

feature: String

required_feature: String

VersionIncompatible

Version compatibility errors

Fields

message: String

ResourceLimitExceeded

Resource limit exceeded

Fields

resource: String

current: usize

limit: usize

SecurityViolation(String)

Security policy violation

Internal(String)

Internal consistency error (should not happen)

Implementations

impl CoreError

pub const fn category(&self) -> ErrorCategory

Get error category for filtering/grouping

Returns the category that best describes the type of error, useful for organizing errors in user interfaces or logs.

pub const fn suggestion(&self) -> Option<&'static str>

Get suggested action for this error

Provides actionable advice for resolving common error scenarios. Returns None for errors that don’t have standard solutions.

impl CoreError

pub fn parse<T: Display>(message: T) -> Self

Create parse error from message

pub fn internal<T: Display>(message: T) -> Self

Create internal error (indicates a bug)

pub const fn is_recoverable(&self) -> bool

Check if error is recoverable

pub const fn is_internal_bug(&self) -> bool

Check if error indicates a bug in the library

pub const fn as_parse_error(&self) -> Option<&ParseError>

Get the underlying parse error if this is a parse error

pub const fn line_number(&self) -> Option<usize>

Get line number for errors that have location information

pub fn is_parse_error_type(&self, error_type: &str) -> bool

Check if this is a specific type of parse error

impl CoreError

pub fn invalid_color<T: Display>(format: T) -> Self

Create color error from invalid format

pub fn invalid_numeric<T: Display>(value: T, reason: &str) -> Self

Create numeric error from parsing failure

pub fn invalid_time<T: Display>(time: T, reason: &str) -> Self

Create time error from invalid format

pub const fn utf8_error(position: usize, message: String) -> Self

Create UTF-8 error with position

pub fn feature_not_supported(feature: &str, required_feature: &str) -> Self

Create feature not supported error

pub fn resource_limit_exceeded( resource: &str, current: usize, limit: usize, ) -> Self

Create resource limit error

Trait Implementations

impl Clone for CoreError

fn clone(&self) -> CoreError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CoreError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for CoreError

std compatible Display implementation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for CoreError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for CoreError

Convert from standard I/O errors (when std is available)

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<ParseError> for CoreError

Convert from parser errors

fn from(err: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for CoreError

Convert from float parse errors

fn from(err: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for CoreError

Convert from integer parse errors

fn from(err: ParseIntError) -> Self

Converts to this type from the input type.

impl From<Utf8Error> for CoreError

Convert from core::str::Utf8Error

fn from(err: Utf8Error) -> Self

Converts to this type from the input type.

impl PartialEq for CoreError

fn eq(&self, other: &CoreError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CoreError

impl StructuralPartialEq for CoreError