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

use std::{error::Error, fmt, io};

#[derive(Debug)]
pub enum CompressError {
    IOErr(io::Error),
    Overflow,
    Malformed,
}

#[derive(Debug)]
pub enum DecompressError {
    IOErr(io::Error),
    Unsupported,
    Underflow,
    Malformed,
    TypeMismatch,
}

impl From<io::Error> for CompressError {
    fn from(err: io::Error) -> Self {
        CompressError::IOErr(err)
    }
}

impl fmt::Display for CompressError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CompressError::IOErr(e) => write!(f, "{}", e),
            CompressError::Overflow => write!(f, "Buffer is too small"),
            CompressError::Malformed => write!(f, "Invalid arguments"),
        }
    }
}

impl Error for CompressError {}

impl From<io::Error> for DecompressError {
    fn from(err: io::Error) -> Self {
        DecompressError::IOErr(err)
    }
}

impl fmt::Display for DecompressError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DecompressError::IOErr(e) => write!(f, "{}", e),
            DecompressError::Unsupported => write!(f, "Unsupported image format"),
            DecompressError::Malformed => write!(f, "Invalid arguments"),
            DecompressError::Underflow => write!(f, "Buffer underflow detected"),
            DecompressError::TypeMismatch => write!(f, "Image data doesn't match the header"),
        }
    }
}

impl Error for DecompressError {}

#[derive(Debug)]
pub enum HeaderErr {
    IOErr(io::Error),
    WrongMagic,
    WrongValue(String),
}

impl From<io::Error> for HeaderErr {
    fn from(err: io::Error) -> HeaderErr {
        HeaderErr::IOErr(err)
    }
}

impl fmt::Display for HeaderErr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            HeaderErr::IOErr(e) => write!(f, "{}", e),
            HeaderErr::WrongMagic => write!(f, "Header doesn't contain GFWX magic"),
            HeaderErr::WrongValue(e) => write!(f, "Invalid filed value in header: {}", e),
        }
    }
}

impl Error for HeaderErr {}