blp 0.1.37

Blizzard BLP image format reader/writer (Warcraft/World of Warcraft textures)
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

use crate::error::args::ArgVal;
use crate::error::cause::Cause;
use num_enum::TryFromPrimitiveError;
use std::{collections::BTreeMap, fmt, io, sync::Arc};

#[derive(Debug, Clone)]
pub struct BlpError {
    pub key: &'static str,
    pub args: BTreeMap<&'static str, ArgVal>,
    pub causes: Vec<Cause>,
}

impl BlpError {
    #[inline]
    pub fn ctx(self, key: &'static str) -> BlpError {
        BlpError::new(key).push_blp(self)
    }

    #[inline]
    pub fn ctx_with(self, key: &'static str, f: impl FnOnce(BlpError) -> BlpError) -> BlpError {
        f(BlpError::new(key).push_blp(self))
    }

    #[inline]
    pub fn new(key: &'static str) -> Self {
        Self { key, args: BTreeMap::new(), causes: Vec::new() }
    }

    #[inline]
    pub fn with_arg(mut self, name: &'static str, val: impl Into<ArgVal>) -> Self {
        self.args.insert(name, val.into());
        self
    }

    #[inline]
    pub fn with_args(mut self, args: impl IntoIterator<Item = (&'static str, ArgVal)>) -> Self {
        for (k, v) in args {
            self.args.insert(k, v);
        }
        self
    }

    #[inline]
    pub fn push_blp(mut self, cause: BlpError) -> Self {
        self.causes.push(Cause::Blp(cause));
        self
    }

    #[inline]
    pub fn push_std(mut self, cause: impl std::error::Error + Send + Sync + 'static) -> Self {
        self.causes
            .push(Cause::Std(Arc::new(cause)));
        self
    }
}

impl fmt::Display for BlpError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}(", self.key)?;
        let mut first = true;
        for (k, v) in &self.args {
            if !first {
                write!(f, ", ")?;
            }
            first = false;
            write!(f, "{k}={v:?}")?;
        }
        write!(f, ")")
    }
}

impl std::error::Error for BlpError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.causes
            .iter()
            .find_map(|c| match c {
                Cause::Blp(e) => Some(e as &dyn std::error::Error),
                Cause::Std(e) => Some(e.as_ref()),
            })
    }
}

impl From<io::Error> for BlpError {
    fn from(e: io::Error) -> Self {
        BlpError::new("io-error").push_std(e)
    }
}

impl From<image::ImageError> for BlpError {
    fn from(e: image::ImageError) -> Self {
        BlpError::new("image-error").push_std(e)
    }
}

impl From<image::error::DecodingError> for BlpError {
    fn from(e: image::error::DecodingError) -> Self {
        BlpError::new("png-error").push_std(e)
    }
}

impl From<jpeg_decoder::Error> for BlpError {
    fn from(e: jpeg_decoder::Error) -> Self {
        BlpError::new("jpeg-error").push_std(e)
    }
}

impl From<turbojpeg::Error> for BlpError {
    fn from(e: turbojpeg::Error) -> Self {
        BlpError::new("turbojpeg-error").push_std(e)
    }
}

impl<T> From<TryFromPrimitiveError<T>> for BlpError
where
    T: num_enum::TryFromPrimitive + 'static,
    T::Primitive: Copy + Into<u64>,
{
    fn from(_err: TryFromPrimitiveError<T>) -> Self {
        BlpError::new("num-error").with_arg("name", core::any::type_name::<T>())
    }
}