1
1
macro_rules! algos {
2
- ( @algo $algo: ident [ $algo_s: expr] $decoder: ident $encoder: ident<$inner: ident> $( { $( $constructor: tt) * } ) * ) => {
2
+ ( @algo $algo: ident [ $algo_s: expr] $decoder: ident $encoder: ident<$inner: ident>
3
+ { @enc $( $encoder_methods: tt) * }
4
+ { @dec $( $decoder_methods: tt) * }
5
+ ) => {
3
6
#[ cfg( feature = $algo_s) ]
4
7
decoder! {
5
8
#[ doc = concat!( "A " , $algo_s, " decoder, or decompressor" ) ]
6
9
#[ cfg( feature = $algo_s) ]
7
10
$decoder
11
+
12
+ { $( $decoder_methods) * }
8
13
}
9
14
10
15
#[ cfg( feature = $algo_s) ]
@@ -15,12 +20,15 @@ macro_rules! algos {
15
20
pub fn new( inner: $inner) -> Self {
16
21
Self :: with_quality( inner, crate :: Level :: Default )
17
22
}
18
- } $( { $( $constructor) * } ) *
23
+ }
24
+
25
+ { $( $encoder_methods) * }
19
26
}
20
27
} ;
21
28
22
29
( $( $mod: ident) ::+<$inner: ident>) => {
23
- algos!( @algo brotli [ "brotli" ] BrotliDecoder BrotliEncoder <$inner> {
30
+ algos!( @algo brotli [ "brotli" ] BrotliDecoder BrotliEncoder <$inner>
31
+ { @enc
24
32
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
25
33
let params = brotli:: enc:: backward_references:: BrotliEncoderParams :: default ( ) ;
26
34
Self {
@@ -30,9 +38,13 @@ macro_rules! algos {
30
38
) ,
31
39
}
32
40
}
33
- } ) ;
41
+ }
42
+ { @dec }
43
+ ) ;
44
+
45
+ algos!( @algo bzip2 [ "bzip2" ] BzDecoder BzEncoder <$inner>
46
+ { @enc
34
47
35
- algos!( @algo bzip2 [ "bzip2" ] BzDecoder BzEncoder <$inner> {
36
48
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
37
49
Self {
38
50
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -41,9 +53,12 @@ macro_rules! algos {
41
53
) ,
42
54
}
43
55
}
44
- } ) ;
56
+ }
57
+ { @dec }
58
+ ) ;
45
59
46
- algos!( @algo deflate [ "deflate" ] DeflateDecoder DeflateEncoder <$inner> {
60
+ algos!( @algo deflate [ "deflate" ] DeflateDecoder DeflateEncoder <$inner>
61
+ { @enc
47
62
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
48
63
Self {
49
64
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -52,9 +67,13 @@ macro_rules! algos {
52
67
) ,
53
68
}
54
69
}
55
- } ) ;
70
+ }
71
+ { @dec }
72
+ ) ;
73
+
74
+ algos!( @algo gzip [ "gzip" ] GzipDecoder GzipEncoder <$inner>
75
+ { @enc
56
76
57
- algos!( @algo gzip [ "gzip" ] GzipDecoder GzipEncoder <$inner> {
58
77
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
59
78
Self {
60
79
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -63,9 +82,12 @@ macro_rules! algos {
63
82
) ,
64
83
}
65
84
}
66
- } ) ;
85
+ }
86
+ { @dec }
87
+ ) ;
67
88
68
- algos!( @algo zlib [ "zlib" ] ZlibDecoder ZlibEncoder <$inner> {
89
+ algos!( @algo zlib [ "zlib" ] ZlibDecoder ZlibEncoder <$inner>
90
+ { @enc
69
91
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
70
92
Self {
71
93
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -74,9 +96,13 @@ macro_rules! algos {
74
96
) ,
75
97
}
76
98
}
77
- } ) ;
99
+ }
100
+ { @dec }
101
+ ) ;
102
+
103
+ algos!( @algo zstd [ "zstd" ] ZstdDecoder ZstdEncoder <$inner>
104
+ { @enc
78
105
79
- algos!( @algo zstd [ "zstd" ] ZstdDecoder ZstdEncoder <$inner> {
80
106
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
81
107
Self {
82
108
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -106,9 +132,52 @@ macro_rules! algos {
106
132
) ,
107
133
}
108
134
}
109
- } ) ;
110
135
111
- algos!( @algo xz [ "xz" ] XzDecoder XzEncoder <$inner> {
136
+ /// Creates a new encoder, using the specified compression level and pre-trained
137
+ /// dictionary, which will read uncompressed data from the given stream and emit a
138
+ /// compressed stream.
139
+ ///
140
+ /// Dictionaries provide better compression ratios for small files, but are required to
141
+ /// be present during decompression.
142
+ ///
143
+ /// # Errors
144
+ ///
145
+ /// Returns error when `dictionary` is not valid.
146
+ pub fn with_dict( inner: $inner, level: crate :: Level , dictionary: & [ u8 ] ) -> :: std:: io:: Result <Self > {
147
+ Ok ( Self {
148
+ inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
149
+ inner,
150
+ crate :: codec:: ZstdEncoder :: new_with_dict( level. into_zstd( ) , dictionary) ?,
151
+ ) ,
152
+ } )
153
+ }
154
+ }
155
+ { @dec
156
+ /// Creates a new decoder, using the specified compression level and pre-trained
157
+ /// dictionary, which will read compressed data from the given stream and emit an
158
+ /// uncompressed stream.
159
+ ///
160
+ /// Dictionaries provide better compression ratios for small files, but are required to
161
+ /// be present during decompression. The dictionary used must be the same as the one
162
+ /// used for compression.
163
+ ///
164
+ /// # Errors
165
+ ///
166
+ /// Returns error when `dictionary` is not valid.
167
+ pub fn with_dict( inner: $inner, dictionary: & [ u8 ] ) -> :: std:: io:: Result <Self > {
168
+ Ok ( Self {
169
+ inner: crate :: $( $mod:: ) +generic:: Decoder :: new(
170
+ inner,
171
+ crate :: codec:: ZstdDecoder :: new_with_dict( dictionary) ?,
172
+ ) ,
173
+ } )
174
+ }
175
+ }
176
+ ) ;
177
+
178
+ algos!( @algo xz [ "xz" ] XzDecoder XzEncoder <$inner>
179
+ { @enc
180
+
112
181
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
113
182
Self {
114
183
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -117,9 +186,13 @@ macro_rules! algos {
117
186
) ,
118
187
}
119
188
}
120
- } ) ;
189
+ }
190
+ { @dec }
191
+ ) ;
192
+
193
+ algos!( @algo lzma [ "lzma" ] LzmaDecoder LzmaEncoder <$inner>
194
+ { @enc
121
195
122
- algos!( @algo lzma [ "lzma" ] LzmaDecoder LzmaEncoder <$inner> {
123
196
pub fn with_quality( inner: $inner, level: crate :: Level ) -> Self {
124
197
Self {
125
198
inner: crate :: $( $mod:: ) +generic:: Encoder :: new(
@@ -128,6 +201,8 @@ macro_rules! algos {
128
201
) ,
129
202
}
130
203
}
131
- } ) ;
204
+ }
205
+ { @dec }
206
+ ) ;
132
207
}
133
208
}
0 commit comments