wowsunpack 0.31.0

Utility for interacting with World of Warships game assets
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
131
132
133
134
135

use std::fmt;

/// A value that was either successfully recognized as a known variant `T`,
/// or is an unrecognized raw value `Raw`.
///
/// This is conceptually similar to `Result<T, Raw>`, but for cases where the
/// "error" isn't really an error — it's just a value we don't have a typed
/// representation for. The raw value is preserved so callers can inspect or
/// display it.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]
pub enum Recognized<T, Raw = String> {
    Known(T),
    Unknown(Raw),
}

impl<T: Copy, Raw: Copy> Copy for Recognized<T, Raw> {}

impl<T, Raw> Recognized<T, Raw> {
    pub fn known(&self) -> Option<&T> {
        match self {
            Recognized::Known(t) => Some(t),
            Recognized::Unknown(_) => None,
        }
    }

    pub fn into_known(self) -> Option<T> {
        match self {
            Recognized::Known(t) => Some(t),
            Recognized::Unknown(_) => None,
        }
    }

    pub fn unknown(&self) -> Option<&Raw> {
        match self {
            Recognized::Known(_) => None,
            Recognized::Unknown(raw) => Some(raw),
        }
    }

    pub fn into_unknown(self) -> Option<Raw> {
        match self {
            Recognized::Known(_) => None,
            Recognized::Unknown(raw) => Some(raw),
        }
    }

    pub fn is_known(&self) -> bool {
        matches!(self, Recognized::Known(_))
    }

    pub fn is_unknown(&self) -> bool {
        matches!(self, Recognized::Unknown(_))
    }

    pub fn unwrap(self) -> T
    where
        Raw: fmt::Debug,
    {
        match self {
            Recognized::Known(t) => t,
            Recognized::Unknown(raw) => {
                panic!("called `Recognized::unwrap()` on an `Unknown` value: {raw:?}")
            }
        }
    }

    pub fn expect(self, msg: &str) -> T
    where
        Raw: fmt::Debug,
    {
        match self {
            Recognized::Known(t) => t,
            Recognized::Unknown(raw) => panic!("{msg}: {raw:?}"),
        }
    }

    pub fn unwrap_or(self, default: T) -> T {
        match self {
            Recognized::Known(t) => t,
            Recognized::Unknown(_) => default,
        }
    }

    pub fn unwrap_or_else<F: FnOnce(Raw) -> T>(self, f: F) -> T {
        match self {
            Recognized::Known(t) => t,
            Recognized::Unknown(raw) => f(raw),
        }
    }

    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Recognized<U, Raw> {
        match self {
            Recognized::Known(t) => Recognized::Known(f(t)),
            Recognized::Unknown(raw) => Recognized::Unknown(raw),
        }
    }

    pub fn map_unknown<U, F: FnOnce(Raw) -> U>(self, f: F) -> Recognized<T, U> {
        match self {
            Recognized::Known(t) => Recognized::Known(t),
            Recognized::Unknown(raw) => Recognized::Unknown(f(raw)),
        }
    }

    pub fn and_then<U, F: FnOnce(T) -> Recognized<U, Raw>>(self, f: F) -> Recognized<U, Raw> {
        match self {
            Recognized::Known(t) => f(t),
            Recognized::Unknown(raw) => Recognized::Unknown(raw),
        }
    }

    pub fn as_ref(&self) -> Recognized<&T, &Raw> {
        match self {
            Recognized::Known(t) => Recognized::Known(t),
            Recognized::Unknown(raw) => Recognized::Unknown(raw),
        }
    }
}

impl<T, Raw> From<T> for Recognized<T, Raw> {
    fn from(value: T) -> Self {
        Recognized::Known(value)
    }
}

impl<T: fmt::Display, Raw: fmt::Display> fmt::Display for Recognized<T, Raw> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Recognized::Known(t) => t.fmt(f),
            Recognized::Unknown(raw) => raw.fmt(f),
        }
    }
}