1 //! Possible ZIP compression methods.
2 
3 use std::fmt;
4 
5 #[allow(deprecated)]
6 /// Identifies the storage format used to compress a file within a ZIP archive.
7 ///
8 /// Each file's compression method is stored alongside it, allowing the
9 /// contents to be read without context.
10 ///
11 /// When creating ZIP files, you may choose the method to use with
12 /// [`zip::write::FileOptions::compression_method`]
13 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
14 pub enum CompressionMethod {
15     /// Store the file as is
16     Stored,
17     /// Compress the file using Deflate
18     #[cfg(any(
19         feature = "deflate",
20         feature = "deflate-miniz",
21         feature = "deflate-zlib"
22     ))]
23     Deflated,
24     /// Compress the file using BZIP2
25     #[cfg(feature = "bzip2")]
26     Bzip2,
27     /// Unsupported compression method
28     #[deprecated(since = "0.5.7", note = "use the constants instead")]
29     Unsupported(u16),
30 }
31 #[allow(deprecated, missing_docs)]
32 /// All compression methods defined for the ZIP format
33 impl CompressionMethod {
34     pub const STORE: Self = CompressionMethod::Stored;
35     pub const SHRINK: Self = CompressionMethod::Unsupported(1);
36     pub const REDUCE_1: Self = CompressionMethod::Unsupported(2);
37     pub const REDUCE_2: Self = CompressionMethod::Unsupported(3);
38     pub const REDUCE_3: Self = CompressionMethod::Unsupported(4);
39     pub const REDUCE_4: Self = CompressionMethod::Unsupported(5);
40     pub const IMPLODE: Self = CompressionMethod::Unsupported(6);
41     #[cfg(any(
42         feature = "deflate",
43         feature = "deflate-miniz",
44         feature = "deflate-zlib"
45     ))]
46     pub const DEFLATE: Self = CompressionMethod::Deflated;
47     #[cfg(not(any(
48         feature = "deflate",
49         feature = "deflate-miniz",
50         feature = "deflate-zlib"
51     )))]
52     pub const DEFLATE: Self = CompressionMethod::Unsupported(8);
53     pub const DEFLATE64: Self = CompressionMethod::Unsupported(9);
54     pub const PKWARE_IMPLODE: Self = CompressionMethod::Unsupported(10);
55     #[cfg(feature = "bzip2")]
56     pub const BZIP2: Self = CompressionMethod::Bzip2;
57     #[cfg(not(feature = "bzip2"))]
58     pub const BZIP2: Self = CompressionMethod::Unsupported(12);
59     pub const LZMA: Self = CompressionMethod::Unsupported(14);
60     pub const IBM_ZOS_CMPSC: Self = CompressionMethod::Unsupported(16);
61     pub const IBM_TERSE: Self = CompressionMethod::Unsupported(18);
62     pub const ZSTD_DEPRECATED: Self = CompressionMethod::Unsupported(20);
63     pub const ZSTD: Self = CompressionMethod::Unsupported(93);
64     pub const MP3: Self = CompressionMethod::Unsupported(94);
65     pub const XZ: Self = CompressionMethod::Unsupported(95);
66     pub const JPEG: Self = CompressionMethod::Unsupported(96);
67     pub const WAVPACK: Self = CompressionMethod::Unsupported(97);
68     pub const PPMD: Self = CompressionMethod::Unsupported(98);
69 }
70 impl CompressionMethod {
71     /// Converts an u16 to its corresponding CompressionMethod
72     #[deprecated(
73         since = "0.5.7",
74         note = "use a constant to construct a compression method"
75     )]
from_u16(val: u16) -> CompressionMethod76     pub fn from_u16(val: u16) -> CompressionMethod {
77         #[allow(deprecated)]
78         match val {
79             0 => CompressionMethod::Stored,
80             #[cfg(any(
81                 feature = "deflate",
82                 feature = "deflate-miniz",
83                 feature = "deflate-zlib"
84             ))]
85             8 => CompressionMethod::Deflated,
86             #[cfg(feature = "bzip2")]
87             12 => CompressionMethod::Bzip2,
88 
89             v => CompressionMethod::Unsupported(v),
90         }
91     }
92 
93     /// Converts a CompressionMethod to a u16
94     #[deprecated(
95         since = "0.5.7",
96         note = "to match on other compression methods, use a constant"
97     )]
to_u16(self) -> u1698     pub fn to_u16(self) -> u16 {
99         #[allow(deprecated)]
100         match self {
101             CompressionMethod::Stored => 0,
102             #[cfg(any(
103                 feature = "deflate",
104                 feature = "deflate-miniz",
105                 feature = "deflate-zlib"
106             ))]
107             CompressionMethod::Deflated => 8,
108             #[cfg(feature = "bzip2")]
109             CompressionMethod::Bzip2 => 12,
110             CompressionMethod::Unsupported(v) => v,
111         }
112     }
113 }
114 
115 impl fmt::Display for CompressionMethod {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result116     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
117         // Just duplicate what the Debug format looks like, i.e, the enum key:
118         write!(f, "{:?}", self)
119     }
120 }
121 
122 #[cfg(test)]
123 mod test {
124     use super::CompressionMethod;
125 
126     #[test]
from_eq_to()127     fn from_eq_to() {
128         for v in 0..(::std::u16::MAX as u32 + 1) {
129             #[allow(deprecated)]
130             let from = CompressionMethod::from_u16(v as u16);
131             #[allow(deprecated)]
132             let to = from.to_u16() as u32;
133             assert_eq!(v, to);
134         }
135     }
136 
methods() -> Vec<CompressionMethod>137     fn methods() -> Vec<CompressionMethod> {
138         let mut methods = Vec::new();
139         methods.push(CompressionMethod::Stored);
140         #[cfg(any(
141             feature = "deflate",
142             feature = "deflate-miniz",
143             feature = "deflate-zlib"
144         ))]
145         methods.push(CompressionMethod::Deflated);
146         #[cfg(feature = "bzip2")]
147         methods.push(CompressionMethod::Bzip2);
148         methods
149     }
150 
151     #[test]
to_eq_from()152     fn to_eq_from() {
153         fn check_match(method: CompressionMethod) {
154             #[allow(deprecated)]
155             let to = method.to_u16();
156             #[allow(deprecated)]
157             let from = CompressionMethod::from_u16(to);
158             #[allow(deprecated)]
159             let back = from.to_u16();
160             assert_eq!(to, back);
161         }
162 
163         for method in methods() {
164             check_match(method);
165         }
166     }
167 
168     #[test]
to_display_fmt()169     fn to_display_fmt() {
170         fn check_match(method: CompressionMethod) {
171             let debug_str = format!("{:?}", method);
172             let display_str = format!("{}", method);
173             assert_eq!(debug_str, display_str);
174         }
175 
176         for method in methods() {
177             check_match(method);
178         }
179     }
180 }
181