psltools 0.0.1

work with .psl files in Rust
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

// Copyright (c) 2026 Alejandro Gonzales-Irribarren <alejandrxgzi@gmail.com>
// Distributed under the terms of the Apache License, Version 2.0.

use std::{borrow::Cow, fmt};

/// Error types for PSL parsing and processing.
///
/// Represents the conditions that can occur while parsing PSL/PSLx files,
/// performing I/O, validating invariants, or attempting unsupported features.
///
/// # Variants
///
/// * `Io` - I/O errors from file operations
/// * `Format` - Parsing errors carrying a byte offset and a message
/// * `Unsupported` - Feature or format not supported (e.g. gzip without the feature)
/// * `Invariant` - A record violated a structural invariant (used by `check`)
///
/// # Examples
///
/// ```
/// use psltools::PslError;
/// use std::io;
///
/// let io_err = PslError::Io(io::Error::new(io::ErrorKind::NotFound, "file not found"));
/// let format_err = PslError::Format {
///     offset: 100,
///     msg: "invalid psl record".into(),
/// };
/// ```
#[derive(Debug)]
pub enum PslError {
    Io(std::io::Error),
    Format {
        offset: usize,
        msg: Cow<'static, str>,
    },
    Unsupported {
        msg: Cow<'static, str>,
    },
    Invariant {
        line: usize,
        msg: Cow<'static, str>,
    },
}

impl From<std::io::Error> for PslError {
    /// Converts I/O errors into the [`PslError::Io`] variant.
    fn from(value: std::io::Error) -> Self {
        PslError::Io(value)
    }
}

impl fmt::Display for PslError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PslError::Io(err) => write!(f, "I/O error: {err}"),
            PslError::Format { offset, msg } => {
                write!(f, "format error at byte {offset}: {msg}")
            }
            PslError::Unsupported { msg } => write!(f, "unsupported: {msg}"),
            PslError::Invariant { line, msg } => {
                write!(f, "invariant violation at line {line}: {msg}")
            }
        }
    }
}

impl std::error::Error for PslError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            PslError::Io(err) => Some(err),
            _ => None,
        }
    }
}