pub struct AcceptEncoding { /* private fields */ }Expand description
Represents an HTTP Accept-Encoding header with a list of supported encodings and their quality values
Implementations§
Source§impl AcceptEncoding
impl AcceptEncoding
Sourcepub fn new(
encodings: Vec<(Encoding, QualityValue)>,
) -> Result<Self, AcceptEncodingError>
pub fn new( encodings: Vec<(Encoding, QualityValue)>, ) -> Result<Self, AcceptEncodingError>
Creates a new AcceptEncoding from a vector of encodings with their quality values.
Examples found in repository?
examples/basic_usage.rs (line 74)
31fn accept_encoding_examples() {
32 println!("1. Accept-Encoding Header Examples");
33 println!("==================================");
34
35 // Example 1a: Encoding Accept-Encoding header values
36 println!("\n1a. Encoding Accept-Encoding header values:");
37 let encodings = vec![
38 (Encoding::Gzip, 1.0),
39 (Encoding::Deflate, 0.8),
40 (Encoding::Br, 0.6),
41 (Encoding::Identity, 0.1),
42 ];
43
44 match encode_header_value(&encodings) {
45 Ok(header_value) => {
46 println!(" Input: {:?}", encodings);
47 println!(" Encoded header: {}", header_value);
48 }
49 Err(e) => println!(" Error encoding: {}", e),
50 }
51
52 // Example 1b: Decoding Accept-Encoding header values
53 println!("\n1b. Decoding Accept-Encoding header values:");
54 let header_string = "gzip, deflate;q=0.8, br;q=0.6, identity;q=0.1";
55 println!(" Input header: {}", header_string);
56
57 match decode_header_value(header_string) {
58 Ok(parsed) => {
59 println!(" Decoded encodings:");
60 for (encoding, quality) in parsed {
61 println!(" {} (q={})", encoding, quality);
62 }
63 }
64 Err(e) => println!(" Error decoding: {}", e),
65 }
66
67 // Example 1c: Working with complex Accept-Encoding values
68 println!("\n1c. Complex Accept-Encoding example:");
69 let complex_header = "gzip;q=1.0, deflate;q=0.5, br;q=0.25, *;q=0.1";
70 println!(" Input: {}", complex_header);
71
72 if let Ok(parsed) = decode_header_value(complex_header) {
73 // Create AcceptEncoding instance
74 if let Ok(accept_encoding) = AcceptEncoding::new(parsed) {
75 println!(
76 " Created AcceptEncoding with {} encodings",
77 accept_encoding.items().len()
78 );
79
80 // Re-encode it
81 if let Ok(re_encoded) = encode_header_value(accept_encoding.items()) {
82 println!(" Re-encoded: {}", re_encoded);
83 }
84 }
85 }
86}
87
88/// Examples for Content-Encoding header encode/decode functionality
89#[cfg(feature = "http_crates")]
90fn content_encoding_examples() {
91 println!("\n\n2. Content-Encoding Header Examples");
92 println!("===================================");
93
94 // Example 2a: Creating and encoding Content-Encoding headers
95 println!("\n2a. Creating and encoding Content-Encoding:");
96 let content_encoding = ContentEncoding::new(Encoding::Gzip);
97 println!(" Created ContentEncoding: {:?}", content_encoding);
98
99 // Use with HeaderMap
100 let mut headers = HeaderMap::new();
101 headers.typed_insert(content_encoding);
102
103 if let Some(header_value) = headers.get(http::header::CONTENT_ENCODING) {
104 println!(
105 " Header value: {}",
106 header_value.to_str().unwrap_or("invalid")
107 );
108 }
109
110 // Example 2b: Decoding Content-Encoding headers
111 println!("\n2b. Decoding Content-Encoding headers:");
112 let test_values = vec!["gzip", "deflate", "br", "zstd"];
113
114 for encoding_str in test_values {
115 println!(" Testing: {}", encoding_str);
116 let header_values = vec![HeaderValue::from_str(encoding_str).unwrap()];
117
118 match ContentEncoding::decode(&mut header_values.iter()) {
119 Ok(decoded) => println!(" Decoded: {:?}", decoded),
120 Err(e) => println!(" Error: {:?}", e),
121 }
122 }
123
124 // Example 2c: Multiple identical values (valid)
125 println!("\n2c. Multiple identical Content-Encoding values:");
126 let identical_values = vec![
127 HeaderValue::from_str("gzip").unwrap(),
128 HeaderValue::from_str("gzip").unwrap(),
129 ];
130
131 match ContentEncoding::decode(&mut identical_values.iter()) {
132 Ok(decoded) => println!(" Multiple identical values decoded: {:?}", decoded),
133 Err(e) => println!(" Error: {:?}", e),
134 }
135
136 // Example 2d: Conflicting values (should error)
137 println!("\n2d. Conflicting Content-Encoding values (should error):");
138 let conflicting_values = vec![
139 HeaderValue::from_str("gzip").unwrap(),
140 HeaderValue::from_str("deflate").unwrap(),
141 ];
142
143 match ContentEncoding::decode(&mut conflicting_values.iter()) {
144 Ok(decoded) => println!(" Unexpectedly decoded: {:?}", decoded),
145 Err(_) => println!(" Correctly rejected conflicting values"),
146 }
147}
148
149#[cfg(not(feature = "http_crates"))]
150fn content_encoding_examples() {
151 println!("\n\n2. Content-Encoding Header Examples");
152 println!("===================================");
153 println!(" (Skipped - http_crates feature not enabled)");
154}
155
156/// Examples for AcceptEncoding advanced functionality
157fn accept_encoding_advanced_examples() {
158 println!("\n\n3. AcceptEncoding Advanced Usage");
159 println!("===============================");
160
161 // Create an AcceptEncoding instance with various encodings
162 let encodings = vec![
163 (Encoding::Gzip, 0.9),
164 (Encoding::Deflate, 0.8),
165 (Encoding::Br, 1.0), // Highest quality
166 (Encoding::Identity, 0.1), // Lowest quality
167 (Encoding::Zstd, 0.7),
168 ];
169
170 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
171 println!("\n3a. Original AcceptEncoding:");
172 println!(" Encodings: {:?}", accept_encoding.items());
173
174 // Example 3a: Finding preferred encoding
175 println!("\n3b. Finding preferred encoding:");
176 if let Some(preferred) = accept_encoding.preferred() {
177 println!(" Preferred encoding: {}", preferred);
178 println!(" (Highest quality value from unsorted list)");
179 }
180
181 // Example 3b: Sorting in descending order (highest quality first)
182 println!("\n3c. Sorting in descending order (highest quality first):");
183 accept_encoding.sort_descending();
184 println!(" After sort_descending():");
185 for (encoding, quality) in accept_encoding.items() {
186 println!(" {} (q={})", encoding, quality);
187 }
188
189 // Now preferred should be first item
190 if let Some(preferred) = accept_encoding.preferred() {
191 println!(" Preferred encoding after sorting: {}", preferred);
192 println!(" (First item in descending sorted list)");
193 }
194
195 // Example 3c: Sorting in ascending order (lowest quality first)
196 println!("\n3d. Sorting in ascending order (lowest quality first):");
197 accept_encoding.sort_ascending();
198 println!(" After sort_ascending():");
199 for (encoding, quality) in accept_encoding.items() {
200 println!(" {} (q={})", encoding, quality);
201 }
202
203 // Now preferred should be last item
204 if let Some(preferred) = accept_encoding.preferred() {
205 println!(" Preferred encoding after ascending sort: {}", preferred);
206 println!(" (Last item in ascending sorted list)");
207 }
208
209 // Example 3d: Demonstrating in-place sorting behavior
210 println!("\n3e. Demonstrating in-place sorting chain:");
211 let encodings2 = vec![
212 (Encoding::Gzip, 0.5),
213 (Encoding::Deflate, 0.9),
214 (Encoding::Br, 0.3),
215 ];
216
217 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
218 println!(" Original: {:?}", accept_encoding2.items());
219
220 // Chain sorting operations (returns &mut Self for chaining)
221 accept_encoding2.sort_descending();
222 println!(" Descending: {:?}", accept_encoding2.items());
223
224 // Sort back to ascending
225 accept_encoding2.sort_ascending();
226 println!(" Ascending: {:?}", accept_encoding2.items());
227
228 println!("\n3f. Practical example - Content negotiation:");
229 practical_content_negotiation_example();
230}
231
232/// A practical example showing how to use these functions for content negotiation
233fn practical_content_negotiation_example() {
234 // Simulate a client's Accept-Encoding header
235 let client_header = "br;q=1.0, gzip;q=0.8, deflate;q=0.6, *;q=0.1";
236 println!(" Client Accept-Encoding: {}", client_header);
237
238 // Server supported encodings (in order of preference)
239 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
240 println!(" Server supported: {:?}", server_supported);
241
242 // Parse client preferences
243 if let Ok(client_encodings) = decode_header_value(client_header) {
244 if let Ok(mut accept_encoding) = AcceptEncoding::new(client_encodings) {
245 // Sort by client preference (highest quality first)
246 accept_encoding.sort_descending();
247
248 // Find the best match
249 let mut selected_encoding = None;
250 for (encoding, quality) in accept_encoding.items() {
251 if server_supported.contains(encoding) && *quality > 0.0 {
252 selected_encoding = Some(encoding);
253 break;
254 }
255 }
256
257 match selected_encoding {
258 Some(encoding) => {
259 println!(" Selected encoding: {}", encoding);
260 println!(" Server should use Content-Encoding: {}", encoding);
261 }
262 None => println!(" No acceptable encoding found"),
263 }
264 }
265 }
266}More examples
examples/accept_encoding_preferred.rs (line 23)
11fn main() {
12 println!("=== AcceptEncoding Preferred and Sorting Examples ===\n");
13
14 // Create an AcceptEncoding with different quality values
15 let encodings = vec![
16 (Encoding::Gzip, 0.7),
17 (Encoding::Deflate, 0.9), // This should be preferred (highest quality)
18 (Encoding::Br, 1.0), // Highest quality, but might not be allowed by server
19 (Encoding::Identity, 0.1),
20 (Encoding::Zstd, 0.8), // High quality compression
21 ];
22
23 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
24
25 println!("Original encodings:");
26 print_encodings(&accept_encoding);
27
28 // Find preferred encoding from unsorted list
29 println!("\n1. Finding preferred encoding (unsorted) - preferred():");
30 if let Some(preferred) = accept_encoding.preferred() {
31 println!(
32 " Preferred: {} (finds highest quality from unsorted list)",
33 preferred
34 );
35 }
36
37 // Example server capabilities - let's say server only supports some encodings
38 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
39
40 println!("\n2. Server-side filtering with preferred_allowed():");
41 println!(" Server supports: {:?}", server_supported);
42 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
43 println!(
44 " Preferred (server filtered): {} (highest quality that server supports)",
45 preferred_allowed
46 );
47 }
48
49 // Compare different server capabilities
50 let limited_server = vec![Encoding::Identity]; // Very limited server
51 println!("\n Limited server supports only: {:?}", limited_server);
52 if let Some(preferred_limited) = accept_encoding.preferred_allowed(limited_server.iter()) {
53 println!(
54 " Preferred (limited server): {} (only available option)",
55 preferred_limited
56 );
57 } else {
58 println!(" No acceptable encoding found for limited server");
59 }
60
61 let advanced_server = vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip]; // Advanced server
62 println!("\n Advanced server supports: {:?}", advanced_server);
63 if let Some(preferred_advanced) = accept_encoding.preferred_allowed(advanced_server.iter()) {
64 println!(
65 " Preferred (advanced server): {} (best match from advanced capabilities)",
66 preferred_advanced
67 );
68 }
69
70 // Sort descending (highest quality first) - modifies in place
71 println!("\n3. After sorting descending (in-place):");
72 accept_encoding.sort_descending();
73 print_encodings(&accept_encoding);
74
75 if let Some(preferred) = accept_encoding.preferred() {
76 println!(
77 " Preferred: {} (first item when sorted descending)",
78 preferred
79 );
80 }
81
82 // Test preferred_allowed with sorted list
83 println!("\n Server-side filtering after sorting descending:");
84 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
85 println!(
86 " Preferred (server filtered): {} (efficiently finds first match in sorted list)",
87 preferred_allowed
88 );
89 }
90
91 // Sort ascending (lowest quality first) - modifies in place
92 println!("\n4. After sorting ascending (in-place):");
93 accept_encoding.sort_ascending();
94 print_encodings(&accept_encoding);
95
96 if let Some(preferred) = accept_encoding.preferred() {
97 println!(
98 " Preferred: {} (last item when sorted ascending)",
99 preferred
100 );
101 }
102
103 // Test preferred_allowed with ascending sorted list
104 println!("\n Server-side filtering after sorting ascending:");
105 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
106 println!(
107 " Preferred (server filtered): {} (efficiently finds best match from end)",
108 preferred_allowed
109 );
110 }
111
112 // Demonstrate chaining - sort methods return &mut Self for chaining
113 println!("\n5. Method chaining example:");
114 let encodings2 = vec![
115 (Encoding::Gzip, 0.3),
116 (Encoding::Deflate, 0.8),
117 (Encoding::Br, 0.6),
118 ];
119
120 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
121
122 // Chain operations
123 let preferred_after_desc_sort = accept_encoding2.sort_descending().preferred().cloned(); // Clone the encoding to avoid borrowing issues
124
125 println!(
126 " After chaining sort_descending().preferred(): {:?}",
127 preferred_after_desc_sort
128 );
129
130 // Sort back and get preferred
131 let preferred_after_asc_sort = accept_encoding2.sort_ascending().preferred().cloned();
132
133 println!(
134 " After chaining sort_ascending().preferred(): {:?}",
135 preferred_after_asc_sort
136 );
137
138 // Demonstrate with equal quality values
139 println!("\n6. Equal quality values example:");
140 let equal_encodings = vec![
141 (Encoding::Gzip, 0.8),
142 (Encoding::Deflate, 0.8), // Same quality
143 (Encoding::Br, 0.8), // Same quality
144 ];
145
146 let mut equal_accept = AcceptEncoding::new(equal_encodings).unwrap();
147 println!(" Original (all equal quality):");
148 print_encodings(&equal_accept);
149
150 if let Some(preferred) = equal_accept.preferred() {
151 println!(
152 " Preferred from equal qualities: {} (first found with max quality)",
153 preferred
154 );
155 }
156
157 // Test server filtering with equal qualities
158 let partial_server = vec![Encoding::Deflate, Encoding::Br];
159 if let Some(preferred_filtered) = equal_accept.preferred_allowed(partial_server.iter()) {
160 println!(
161 " Preferred (server filtered from equal qualities): {} (first allowed match)",
162 preferred_filtered
163 );
164 }
165
166 equal_accept.sort_descending();
167 println!(" After sort_descending (stable sort preserves original order for equal elements):");
168 print_encodings(&equal_accept);
169
170 // Demonstrate practical content negotiation scenario
171 println!("\n7. Practical content negotiation scenario:");
172 practical_negotiation_example();
173}
174
175fn print_encodings(accept_encoding: &AcceptEncoding) {
176 for (encoding, quality) in accept_encoding.items() {
177 println!(" {} (q={})", encoding, quality);
178 }
179}
180
181/// Demonstrates practical content negotiation comparing both methods
182fn practical_negotiation_example() {
183 println!(
184 " Scenario: Client sends 'Accept-Encoding: br;q=1.0, zstd;q=0.9, gzip;q=0.7, deflate;q=0.5'"
185 );
186
187 let client_preferences = vec![
188 (Encoding::Br, 1.0), // Client's top choice
189 (Encoding::Zstd, 0.9), // Second choice
190 (Encoding::Gzip, 0.7), // Third choice
191 (Encoding::Deflate, 0.5), // Fallback
192 ];
193
194 let accept_encoding = AcceptEncoding::new(client_preferences).unwrap();
195
196 // Method 1: preferred() - ignores server capabilities
197 if let Some(client_preferred) = accept_encoding.preferred() {
198 println!(
199 " preferred(): {} (client's top choice, ignoring server)",
200 client_preferred
201 );
202 }
203
204 // Different server scenarios
205 let scenarios = vec![
206 (
207 "Basic server",
208 vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity],
209 ),
210 (
211 "Advanced server",
212 vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip],
213 ),
214 ("Legacy server", vec![Encoding::Deflate, Encoding::Identity]),
215 (
216 "Modern server",
217 vec![
218 Encoding::Br,
219 Encoding::Zstd,
220 Encoding::Gzip,
221 Encoding::Deflate,
222 ],
223 ),
224 ];
225
226 for (server_name, server_caps) in scenarios {
227 print!(" {}: supports {:?}", server_name, server_caps);
228
229 if let Some(negotiated) = accept_encoding.preferred_allowed(server_caps.iter()) {
230 println!(" → selected: {}", negotiated);
231 } else {
232 println!(" → no acceptable encoding found");
233 }
234 }
235
236 println!("\n Key difference:");
237 println!(" - preferred(): Returns client's top choice regardless of server capabilities");
238 println!(" - preferred_allowed(): Returns best mutually supported encoding");
239 println!(" - Both methods honor the current sorting state for efficiency");
240}Sourcepub fn items(&self) -> &[(Encoding, QualityValue)]
pub fn items(&self) -> &[(Encoding, QualityValue)]
Returns a reference to the internal vector of encodings and their quality values.
Examples found in repository?
More examples
examples/basic_usage.rs (line 77)
31fn accept_encoding_examples() {
32 println!("1. Accept-Encoding Header Examples");
33 println!("==================================");
34
35 // Example 1a: Encoding Accept-Encoding header values
36 println!("\n1a. Encoding Accept-Encoding header values:");
37 let encodings = vec![
38 (Encoding::Gzip, 1.0),
39 (Encoding::Deflate, 0.8),
40 (Encoding::Br, 0.6),
41 (Encoding::Identity, 0.1),
42 ];
43
44 match encode_header_value(&encodings) {
45 Ok(header_value) => {
46 println!(" Input: {:?}", encodings);
47 println!(" Encoded header: {}", header_value);
48 }
49 Err(e) => println!(" Error encoding: {}", e),
50 }
51
52 // Example 1b: Decoding Accept-Encoding header values
53 println!("\n1b. Decoding Accept-Encoding header values:");
54 let header_string = "gzip, deflate;q=0.8, br;q=0.6, identity;q=0.1";
55 println!(" Input header: {}", header_string);
56
57 match decode_header_value(header_string) {
58 Ok(parsed) => {
59 println!(" Decoded encodings:");
60 for (encoding, quality) in parsed {
61 println!(" {} (q={})", encoding, quality);
62 }
63 }
64 Err(e) => println!(" Error decoding: {}", e),
65 }
66
67 // Example 1c: Working with complex Accept-Encoding values
68 println!("\n1c. Complex Accept-Encoding example:");
69 let complex_header = "gzip;q=1.0, deflate;q=0.5, br;q=0.25, *;q=0.1";
70 println!(" Input: {}", complex_header);
71
72 if let Ok(parsed) = decode_header_value(complex_header) {
73 // Create AcceptEncoding instance
74 if let Ok(accept_encoding) = AcceptEncoding::new(parsed) {
75 println!(
76 " Created AcceptEncoding with {} encodings",
77 accept_encoding.items().len()
78 );
79
80 // Re-encode it
81 if let Ok(re_encoded) = encode_header_value(accept_encoding.items()) {
82 println!(" Re-encoded: {}", re_encoded);
83 }
84 }
85 }
86}
87
88/// Examples for Content-Encoding header encode/decode functionality
89#[cfg(feature = "http_crates")]
90fn content_encoding_examples() {
91 println!("\n\n2. Content-Encoding Header Examples");
92 println!("===================================");
93
94 // Example 2a: Creating and encoding Content-Encoding headers
95 println!("\n2a. Creating and encoding Content-Encoding:");
96 let content_encoding = ContentEncoding::new(Encoding::Gzip);
97 println!(" Created ContentEncoding: {:?}", content_encoding);
98
99 // Use with HeaderMap
100 let mut headers = HeaderMap::new();
101 headers.typed_insert(content_encoding);
102
103 if let Some(header_value) = headers.get(http::header::CONTENT_ENCODING) {
104 println!(
105 " Header value: {}",
106 header_value.to_str().unwrap_or("invalid")
107 );
108 }
109
110 // Example 2b: Decoding Content-Encoding headers
111 println!("\n2b. Decoding Content-Encoding headers:");
112 let test_values = vec!["gzip", "deflate", "br", "zstd"];
113
114 for encoding_str in test_values {
115 println!(" Testing: {}", encoding_str);
116 let header_values = vec![HeaderValue::from_str(encoding_str).unwrap()];
117
118 match ContentEncoding::decode(&mut header_values.iter()) {
119 Ok(decoded) => println!(" Decoded: {:?}", decoded),
120 Err(e) => println!(" Error: {:?}", e),
121 }
122 }
123
124 // Example 2c: Multiple identical values (valid)
125 println!("\n2c. Multiple identical Content-Encoding values:");
126 let identical_values = vec![
127 HeaderValue::from_str("gzip").unwrap(),
128 HeaderValue::from_str("gzip").unwrap(),
129 ];
130
131 match ContentEncoding::decode(&mut identical_values.iter()) {
132 Ok(decoded) => println!(" Multiple identical values decoded: {:?}", decoded),
133 Err(e) => println!(" Error: {:?}", e),
134 }
135
136 // Example 2d: Conflicting values (should error)
137 println!("\n2d. Conflicting Content-Encoding values (should error):");
138 let conflicting_values = vec![
139 HeaderValue::from_str("gzip").unwrap(),
140 HeaderValue::from_str("deflate").unwrap(),
141 ];
142
143 match ContentEncoding::decode(&mut conflicting_values.iter()) {
144 Ok(decoded) => println!(" Unexpectedly decoded: {:?}", decoded),
145 Err(_) => println!(" Correctly rejected conflicting values"),
146 }
147}
148
149#[cfg(not(feature = "http_crates"))]
150fn content_encoding_examples() {
151 println!("\n\n2. Content-Encoding Header Examples");
152 println!("===================================");
153 println!(" (Skipped - http_crates feature not enabled)");
154}
155
156/// Examples for AcceptEncoding advanced functionality
157fn accept_encoding_advanced_examples() {
158 println!("\n\n3. AcceptEncoding Advanced Usage");
159 println!("===============================");
160
161 // Create an AcceptEncoding instance with various encodings
162 let encodings = vec![
163 (Encoding::Gzip, 0.9),
164 (Encoding::Deflate, 0.8),
165 (Encoding::Br, 1.0), // Highest quality
166 (Encoding::Identity, 0.1), // Lowest quality
167 (Encoding::Zstd, 0.7),
168 ];
169
170 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
171 println!("\n3a. Original AcceptEncoding:");
172 println!(" Encodings: {:?}", accept_encoding.items());
173
174 // Example 3a: Finding preferred encoding
175 println!("\n3b. Finding preferred encoding:");
176 if let Some(preferred) = accept_encoding.preferred() {
177 println!(" Preferred encoding: {}", preferred);
178 println!(" (Highest quality value from unsorted list)");
179 }
180
181 // Example 3b: Sorting in descending order (highest quality first)
182 println!("\n3c. Sorting in descending order (highest quality first):");
183 accept_encoding.sort_descending();
184 println!(" After sort_descending():");
185 for (encoding, quality) in accept_encoding.items() {
186 println!(" {} (q={})", encoding, quality);
187 }
188
189 // Now preferred should be first item
190 if let Some(preferred) = accept_encoding.preferred() {
191 println!(" Preferred encoding after sorting: {}", preferred);
192 println!(" (First item in descending sorted list)");
193 }
194
195 // Example 3c: Sorting in ascending order (lowest quality first)
196 println!("\n3d. Sorting in ascending order (lowest quality first):");
197 accept_encoding.sort_ascending();
198 println!(" After sort_ascending():");
199 for (encoding, quality) in accept_encoding.items() {
200 println!(" {} (q={})", encoding, quality);
201 }
202
203 // Now preferred should be last item
204 if let Some(preferred) = accept_encoding.preferred() {
205 println!(" Preferred encoding after ascending sort: {}", preferred);
206 println!(" (Last item in ascending sorted list)");
207 }
208
209 // Example 3d: Demonstrating in-place sorting behavior
210 println!("\n3e. Demonstrating in-place sorting chain:");
211 let encodings2 = vec![
212 (Encoding::Gzip, 0.5),
213 (Encoding::Deflate, 0.9),
214 (Encoding::Br, 0.3),
215 ];
216
217 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
218 println!(" Original: {:?}", accept_encoding2.items());
219
220 // Chain sorting operations (returns &mut Self for chaining)
221 accept_encoding2.sort_descending();
222 println!(" Descending: {:?}", accept_encoding2.items());
223
224 // Sort back to ascending
225 accept_encoding2.sort_ascending();
226 println!(" Ascending: {:?}", accept_encoding2.items());
227
228 println!("\n3f. Practical example - Content negotiation:");
229 practical_content_negotiation_example();
230}
231
232/// A practical example showing how to use these functions for content negotiation
233fn practical_content_negotiation_example() {
234 // Simulate a client's Accept-Encoding header
235 let client_header = "br;q=1.0, gzip;q=0.8, deflate;q=0.6, *;q=0.1";
236 println!(" Client Accept-Encoding: {}", client_header);
237
238 // Server supported encodings (in order of preference)
239 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
240 println!(" Server supported: {:?}", server_supported);
241
242 // Parse client preferences
243 if let Ok(client_encodings) = decode_header_value(client_header) {
244 if let Ok(mut accept_encoding) = AcceptEncoding::new(client_encodings) {
245 // Sort by client preference (highest quality first)
246 accept_encoding.sort_descending();
247
248 // Find the best match
249 let mut selected_encoding = None;
250 for (encoding, quality) in accept_encoding.items() {
251 if server_supported.contains(encoding) && *quality > 0.0 {
252 selected_encoding = Some(encoding);
253 break;
254 }
255 }
256
257 match selected_encoding {
258 Some(encoding) => {
259 println!(" Selected encoding: {}", encoding);
260 println!(" Server should use Content-Encoding: {}", encoding);
261 }
262 None => println!(" No acceptable encoding found"),
263 }
264 }
265 }
266}Sourcepub fn sort_descending(&mut self) -> &mut Self
pub fn sort_descending(&mut self) -> &mut Self
Sorts the encodings by quality value in descending order and returns self.
Examples found in repository?
examples/basic_usage.rs (line 183)
157fn accept_encoding_advanced_examples() {
158 println!("\n\n3. AcceptEncoding Advanced Usage");
159 println!("===============================");
160
161 // Create an AcceptEncoding instance with various encodings
162 let encodings = vec![
163 (Encoding::Gzip, 0.9),
164 (Encoding::Deflate, 0.8),
165 (Encoding::Br, 1.0), // Highest quality
166 (Encoding::Identity, 0.1), // Lowest quality
167 (Encoding::Zstd, 0.7),
168 ];
169
170 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
171 println!("\n3a. Original AcceptEncoding:");
172 println!(" Encodings: {:?}", accept_encoding.items());
173
174 // Example 3a: Finding preferred encoding
175 println!("\n3b. Finding preferred encoding:");
176 if let Some(preferred) = accept_encoding.preferred() {
177 println!(" Preferred encoding: {}", preferred);
178 println!(" (Highest quality value from unsorted list)");
179 }
180
181 // Example 3b: Sorting in descending order (highest quality first)
182 println!("\n3c. Sorting in descending order (highest quality first):");
183 accept_encoding.sort_descending();
184 println!(" After sort_descending():");
185 for (encoding, quality) in accept_encoding.items() {
186 println!(" {} (q={})", encoding, quality);
187 }
188
189 // Now preferred should be first item
190 if let Some(preferred) = accept_encoding.preferred() {
191 println!(" Preferred encoding after sorting: {}", preferred);
192 println!(" (First item in descending sorted list)");
193 }
194
195 // Example 3c: Sorting in ascending order (lowest quality first)
196 println!("\n3d. Sorting in ascending order (lowest quality first):");
197 accept_encoding.sort_ascending();
198 println!(" After sort_ascending():");
199 for (encoding, quality) in accept_encoding.items() {
200 println!(" {} (q={})", encoding, quality);
201 }
202
203 // Now preferred should be last item
204 if let Some(preferred) = accept_encoding.preferred() {
205 println!(" Preferred encoding after ascending sort: {}", preferred);
206 println!(" (Last item in ascending sorted list)");
207 }
208
209 // Example 3d: Demonstrating in-place sorting behavior
210 println!("\n3e. Demonstrating in-place sorting chain:");
211 let encodings2 = vec![
212 (Encoding::Gzip, 0.5),
213 (Encoding::Deflate, 0.9),
214 (Encoding::Br, 0.3),
215 ];
216
217 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
218 println!(" Original: {:?}", accept_encoding2.items());
219
220 // Chain sorting operations (returns &mut Self for chaining)
221 accept_encoding2.sort_descending();
222 println!(" Descending: {:?}", accept_encoding2.items());
223
224 // Sort back to ascending
225 accept_encoding2.sort_ascending();
226 println!(" Ascending: {:?}", accept_encoding2.items());
227
228 println!("\n3f. Practical example - Content negotiation:");
229 practical_content_negotiation_example();
230}
231
232/// A practical example showing how to use these functions for content negotiation
233fn practical_content_negotiation_example() {
234 // Simulate a client's Accept-Encoding header
235 let client_header = "br;q=1.0, gzip;q=0.8, deflate;q=0.6, *;q=0.1";
236 println!(" Client Accept-Encoding: {}", client_header);
237
238 // Server supported encodings (in order of preference)
239 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
240 println!(" Server supported: {:?}", server_supported);
241
242 // Parse client preferences
243 if let Ok(client_encodings) = decode_header_value(client_header) {
244 if let Ok(mut accept_encoding) = AcceptEncoding::new(client_encodings) {
245 // Sort by client preference (highest quality first)
246 accept_encoding.sort_descending();
247
248 // Find the best match
249 let mut selected_encoding = None;
250 for (encoding, quality) in accept_encoding.items() {
251 if server_supported.contains(encoding) && *quality > 0.0 {
252 selected_encoding = Some(encoding);
253 break;
254 }
255 }
256
257 match selected_encoding {
258 Some(encoding) => {
259 println!(" Selected encoding: {}", encoding);
260 println!(" Server should use Content-Encoding: {}", encoding);
261 }
262 None => println!(" No acceptable encoding found"),
263 }
264 }
265 }
266}More examples
examples/accept_encoding_preferred.rs (line 72)
11fn main() {
12 println!("=== AcceptEncoding Preferred and Sorting Examples ===\n");
13
14 // Create an AcceptEncoding with different quality values
15 let encodings = vec![
16 (Encoding::Gzip, 0.7),
17 (Encoding::Deflate, 0.9), // This should be preferred (highest quality)
18 (Encoding::Br, 1.0), // Highest quality, but might not be allowed by server
19 (Encoding::Identity, 0.1),
20 (Encoding::Zstd, 0.8), // High quality compression
21 ];
22
23 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
24
25 println!("Original encodings:");
26 print_encodings(&accept_encoding);
27
28 // Find preferred encoding from unsorted list
29 println!("\n1. Finding preferred encoding (unsorted) - preferred():");
30 if let Some(preferred) = accept_encoding.preferred() {
31 println!(
32 " Preferred: {} (finds highest quality from unsorted list)",
33 preferred
34 );
35 }
36
37 // Example server capabilities - let's say server only supports some encodings
38 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
39
40 println!("\n2. Server-side filtering with preferred_allowed():");
41 println!(" Server supports: {:?}", server_supported);
42 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
43 println!(
44 " Preferred (server filtered): {} (highest quality that server supports)",
45 preferred_allowed
46 );
47 }
48
49 // Compare different server capabilities
50 let limited_server = vec![Encoding::Identity]; // Very limited server
51 println!("\n Limited server supports only: {:?}", limited_server);
52 if let Some(preferred_limited) = accept_encoding.preferred_allowed(limited_server.iter()) {
53 println!(
54 " Preferred (limited server): {} (only available option)",
55 preferred_limited
56 );
57 } else {
58 println!(" No acceptable encoding found for limited server");
59 }
60
61 let advanced_server = vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip]; // Advanced server
62 println!("\n Advanced server supports: {:?}", advanced_server);
63 if let Some(preferred_advanced) = accept_encoding.preferred_allowed(advanced_server.iter()) {
64 println!(
65 " Preferred (advanced server): {} (best match from advanced capabilities)",
66 preferred_advanced
67 );
68 }
69
70 // Sort descending (highest quality first) - modifies in place
71 println!("\n3. After sorting descending (in-place):");
72 accept_encoding.sort_descending();
73 print_encodings(&accept_encoding);
74
75 if let Some(preferred) = accept_encoding.preferred() {
76 println!(
77 " Preferred: {} (first item when sorted descending)",
78 preferred
79 );
80 }
81
82 // Test preferred_allowed with sorted list
83 println!("\n Server-side filtering after sorting descending:");
84 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
85 println!(
86 " Preferred (server filtered): {} (efficiently finds first match in sorted list)",
87 preferred_allowed
88 );
89 }
90
91 // Sort ascending (lowest quality first) - modifies in place
92 println!("\n4. After sorting ascending (in-place):");
93 accept_encoding.sort_ascending();
94 print_encodings(&accept_encoding);
95
96 if let Some(preferred) = accept_encoding.preferred() {
97 println!(
98 " Preferred: {} (last item when sorted ascending)",
99 preferred
100 );
101 }
102
103 // Test preferred_allowed with ascending sorted list
104 println!("\n Server-side filtering after sorting ascending:");
105 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
106 println!(
107 " Preferred (server filtered): {} (efficiently finds best match from end)",
108 preferred_allowed
109 );
110 }
111
112 // Demonstrate chaining - sort methods return &mut Self for chaining
113 println!("\n5. Method chaining example:");
114 let encodings2 = vec![
115 (Encoding::Gzip, 0.3),
116 (Encoding::Deflate, 0.8),
117 (Encoding::Br, 0.6),
118 ];
119
120 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
121
122 // Chain operations
123 let preferred_after_desc_sort = accept_encoding2.sort_descending().preferred().cloned(); // Clone the encoding to avoid borrowing issues
124
125 println!(
126 " After chaining sort_descending().preferred(): {:?}",
127 preferred_after_desc_sort
128 );
129
130 // Sort back and get preferred
131 let preferred_after_asc_sort = accept_encoding2.sort_ascending().preferred().cloned();
132
133 println!(
134 " After chaining sort_ascending().preferred(): {:?}",
135 preferred_after_asc_sort
136 );
137
138 // Demonstrate with equal quality values
139 println!("\n6. Equal quality values example:");
140 let equal_encodings = vec![
141 (Encoding::Gzip, 0.8),
142 (Encoding::Deflate, 0.8), // Same quality
143 (Encoding::Br, 0.8), // Same quality
144 ];
145
146 let mut equal_accept = AcceptEncoding::new(equal_encodings).unwrap();
147 println!(" Original (all equal quality):");
148 print_encodings(&equal_accept);
149
150 if let Some(preferred) = equal_accept.preferred() {
151 println!(
152 " Preferred from equal qualities: {} (first found with max quality)",
153 preferred
154 );
155 }
156
157 // Test server filtering with equal qualities
158 let partial_server = vec![Encoding::Deflate, Encoding::Br];
159 if let Some(preferred_filtered) = equal_accept.preferred_allowed(partial_server.iter()) {
160 println!(
161 " Preferred (server filtered from equal qualities): {} (first allowed match)",
162 preferred_filtered
163 );
164 }
165
166 equal_accept.sort_descending();
167 println!(" After sort_descending (stable sort preserves original order for equal elements):");
168 print_encodings(&equal_accept);
169
170 // Demonstrate practical content negotiation scenario
171 println!("\n7. Practical content negotiation scenario:");
172 practical_negotiation_example();
173}Sourcepub fn sort_ascending(&mut self) -> &mut Self
pub fn sort_ascending(&mut self) -> &mut Self
Sorts the encodings by quality value in ascending order and returns self.
Examples found in repository?
examples/basic_usage.rs (line 197)
157fn accept_encoding_advanced_examples() {
158 println!("\n\n3. AcceptEncoding Advanced Usage");
159 println!("===============================");
160
161 // Create an AcceptEncoding instance with various encodings
162 let encodings = vec![
163 (Encoding::Gzip, 0.9),
164 (Encoding::Deflate, 0.8),
165 (Encoding::Br, 1.0), // Highest quality
166 (Encoding::Identity, 0.1), // Lowest quality
167 (Encoding::Zstd, 0.7),
168 ];
169
170 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
171 println!("\n3a. Original AcceptEncoding:");
172 println!(" Encodings: {:?}", accept_encoding.items());
173
174 // Example 3a: Finding preferred encoding
175 println!("\n3b. Finding preferred encoding:");
176 if let Some(preferred) = accept_encoding.preferred() {
177 println!(" Preferred encoding: {}", preferred);
178 println!(" (Highest quality value from unsorted list)");
179 }
180
181 // Example 3b: Sorting in descending order (highest quality first)
182 println!("\n3c. Sorting in descending order (highest quality first):");
183 accept_encoding.sort_descending();
184 println!(" After sort_descending():");
185 for (encoding, quality) in accept_encoding.items() {
186 println!(" {} (q={})", encoding, quality);
187 }
188
189 // Now preferred should be first item
190 if let Some(preferred) = accept_encoding.preferred() {
191 println!(" Preferred encoding after sorting: {}", preferred);
192 println!(" (First item in descending sorted list)");
193 }
194
195 // Example 3c: Sorting in ascending order (lowest quality first)
196 println!("\n3d. Sorting in ascending order (lowest quality first):");
197 accept_encoding.sort_ascending();
198 println!(" After sort_ascending():");
199 for (encoding, quality) in accept_encoding.items() {
200 println!(" {} (q={})", encoding, quality);
201 }
202
203 // Now preferred should be last item
204 if let Some(preferred) = accept_encoding.preferred() {
205 println!(" Preferred encoding after ascending sort: {}", preferred);
206 println!(" (Last item in ascending sorted list)");
207 }
208
209 // Example 3d: Demonstrating in-place sorting behavior
210 println!("\n3e. Demonstrating in-place sorting chain:");
211 let encodings2 = vec![
212 (Encoding::Gzip, 0.5),
213 (Encoding::Deflate, 0.9),
214 (Encoding::Br, 0.3),
215 ];
216
217 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
218 println!(" Original: {:?}", accept_encoding2.items());
219
220 // Chain sorting operations (returns &mut Self for chaining)
221 accept_encoding2.sort_descending();
222 println!(" Descending: {:?}", accept_encoding2.items());
223
224 // Sort back to ascending
225 accept_encoding2.sort_ascending();
226 println!(" Ascending: {:?}", accept_encoding2.items());
227
228 println!("\n3f. Practical example - Content negotiation:");
229 practical_content_negotiation_example();
230}More examples
examples/accept_encoding_preferred.rs (line 93)
11fn main() {
12 println!("=== AcceptEncoding Preferred and Sorting Examples ===\n");
13
14 // Create an AcceptEncoding with different quality values
15 let encodings = vec![
16 (Encoding::Gzip, 0.7),
17 (Encoding::Deflate, 0.9), // This should be preferred (highest quality)
18 (Encoding::Br, 1.0), // Highest quality, but might not be allowed by server
19 (Encoding::Identity, 0.1),
20 (Encoding::Zstd, 0.8), // High quality compression
21 ];
22
23 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
24
25 println!("Original encodings:");
26 print_encodings(&accept_encoding);
27
28 // Find preferred encoding from unsorted list
29 println!("\n1. Finding preferred encoding (unsorted) - preferred():");
30 if let Some(preferred) = accept_encoding.preferred() {
31 println!(
32 " Preferred: {} (finds highest quality from unsorted list)",
33 preferred
34 );
35 }
36
37 // Example server capabilities - let's say server only supports some encodings
38 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
39
40 println!("\n2. Server-side filtering with preferred_allowed():");
41 println!(" Server supports: {:?}", server_supported);
42 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
43 println!(
44 " Preferred (server filtered): {} (highest quality that server supports)",
45 preferred_allowed
46 );
47 }
48
49 // Compare different server capabilities
50 let limited_server = vec![Encoding::Identity]; // Very limited server
51 println!("\n Limited server supports only: {:?}", limited_server);
52 if let Some(preferred_limited) = accept_encoding.preferred_allowed(limited_server.iter()) {
53 println!(
54 " Preferred (limited server): {} (only available option)",
55 preferred_limited
56 );
57 } else {
58 println!(" No acceptable encoding found for limited server");
59 }
60
61 let advanced_server = vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip]; // Advanced server
62 println!("\n Advanced server supports: {:?}", advanced_server);
63 if let Some(preferred_advanced) = accept_encoding.preferred_allowed(advanced_server.iter()) {
64 println!(
65 " Preferred (advanced server): {} (best match from advanced capabilities)",
66 preferred_advanced
67 );
68 }
69
70 // Sort descending (highest quality first) - modifies in place
71 println!("\n3. After sorting descending (in-place):");
72 accept_encoding.sort_descending();
73 print_encodings(&accept_encoding);
74
75 if let Some(preferred) = accept_encoding.preferred() {
76 println!(
77 " Preferred: {} (first item when sorted descending)",
78 preferred
79 );
80 }
81
82 // Test preferred_allowed with sorted list
83 println!("\n Server-side filtering after sorting descending:");
84 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
85 println!(
86 " Preferred (server filtered): {} (efficiently finds first match in sorted list)",
87 preferred_allowed
88 );
89 }
90
91 // Sort ascending (lowest quality first) - modifies in place
92 println!("\n4. After sorting ascending (in-place):");
93 accept_encoding.sort_ascending();
94 print_encodings(&accept_encoding);
95
96 if let Some(preferred) = accept_encoding.preferred() {
97 println!(
98 " Preferred: {} (last item when sorted ascending)",
99 preferred
100 );
101 }
102
103 // Test preferred_allowed with ascending sorted list
104 println!("\n Server-side filtering after sorting ascending:");
105 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
106 println!(
107 " Preferred (server filtered): {} (efficiently finds best match from end)",
108 preferred_allowed
109 );
110 }
111
112 // Demonstrate chaining - sort methods return &mut Self for chaining
113 println!("\n5. Method chaining example:");
114 let encodings2 = vec![
115 (Encoding::Gzip, 0.3),
116 (Encoding::Deflate, 0.8),
117 (Encoding::Br, 0.6),
118 ];
119
120 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
121
122 // Chain operations
123 let preferred_after_desc_sort = accept_encoding2.sort_descending().preferred().cloned(); // Clone the encoding to avoid borrowing issues
124
125 println!(
126 " After chaining sort_descending().preferred(): {:?}",
127 preferred_after_desc_sort
128 );
129
130 // Sort back and get preferred
131 let preferred_after_asc_sort = accept_encoding2.sort_ascending().preferred().cloned();
132
133 println!(
134 " After chaining sort_ascending().preferred(): {:?}",
135 preferred_after_asc_sort
136 );
137
138 // Demonstrate with equal quality values
139 println!("\n6. Equal quality values example:");
140 let equal_encodings = vec![
141 (Encoding::Gzip, 0.8),
142 (Encoding::Deflate, 0.8), // Same quality
143 (Encoding::Br, 0.8), // Same quality
144 ];
145
146 let mut equal_accept = AcceptEncoding::new(equal_encodings).unwrap();
147 println!(" Original (all equal quality):");
148 print_encodings(&equal_accept);
149
150 if let Some(preferred) = equal_accept.preferred() {
151 println!(
152 " Preferred from equal qualities: {} (first found with max quality)",
153 preferred
154 );
155 }
156
157 // Test server filtering with equal qualities
158 let partial_server = vec![Encoding::Deflate, Encoding::Br];
159 if let Some(preferred_filtered) = equal_accept.preferred_allowed(partial_server.iter()) {
160 println!(
161 " Preferred (server filtered from equal qualities): {} (first allowed match)",
162 preferred_filtered
163 );
164 }
165
166 equal_accept.sort_descending();
167 println!(" After sort_descending (stable sort preserves original order for equal elements):");
168 print_encodings(&equal_accept);
169
170 // Demonstrate practical content negotiation scenario
171 println!("\n7. Practical content negotiation scenario:");
172 practical_negotiation_example();
173}Sourcepub fn preferred(&self) -> Option<&Encoding>
pub fn preferred(&self) -> Option<&Encoding>
Returns the highest-preference encoding.
Examples found in repository?
examples/basic_usage.rs (line 176)
157fn accept_encoding_advanced_examples() {
158 println!("\n\n3. AcceptEncoding Advanced Usage");
159 println!("===============================");
160
161 // Create an AcceptEncoding instance with various encodings
162 let encodings = vec![
163 (Encoding::Gzip, 0.9),
164 (Encoding::Deflate, 0.8),
165 (Encoding::Br, 1.0), // Highest quality
166 (Encoding::Identity, 0.1), // Lowest quality
167 (Encoding::Zstd, 0.7),
168 ];
169
170 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
171 println!("\n3a. Original AcceptEncoding:");
172 println!(" Encodings: {:?}", accept_encoding.items());
173
174 // Example 3a: Finding preferred encoding
175 println!("\n3b. Finding preferred encoding:");
176 if let Some(preferred) = accept_encoding.preferred() {
177 println!(" Preferred encoding: {}", preferred);
178 println!(" (Highest quality value from unsorted list)");
179 }
180
181 // Example 3b: Sorting in descending order (highest quality first)
182 println!("\n3c. Sorting in descending order (highest quality first):");
183 accept_encoding.sort_descending();
184 println!(" After sort_descending():");
185 for (encoding, quality) in accept_encoding.items() {
186 println!(" {} (q={})", encoding, quality);
187 }
188
189 // Now preferred should be first item
190 if let Some(preferred) = accept_encoding.preferred() {
191 println!(" Preferred encoding after sorting: {}", preferred);
192 println!(" (First item in descending sorted list)");
193 }
194
195 // Example 3c: Sorting in ascending order (lowest quality first)
196 println!("\n3d. Sorting in ascending order (lowest quality first):");
197 accept_encoding.sort_ascending();
198 println!(" After sort_ascending():");
199 for (encoding, quality) in accept_encoding.items() {
200 println!(" {} (q={})", encoding, quality);
201 }
202
203 // Now preferred should be last item
204 if let Some(preferred) = accept_encoding.preferred() {
205 println!(" Preferred encoding after ascending sort: {}", preferred);
206 println!(" (Last item in ascending sorted list)");
207 }
208
209 // Example 3d: Demonstrating in-place sorting behavior
210 println!("\n3e. Demonstrating in-place sorting chain:");
211 let encodings2 = vec![
212 (Encoding::Gzip, 0.5),
213 (Encoding::Deflate, 0.9),
214 (Encoding::Br, 0.3),
215 ];
216
217 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
218 println!(" Original: {:?}", accept_encoding2.items());
219
220 // Chain sorting operations (returns &mut Self for chaining)
221 accept_encoding2.sort_descending();
222 println!(" Descending: {:?}", accept_encoding2.items());
223
224 // Sort back to ascending
225 accept_encoding2.sort_ascending();
226 println!(" Ascending: {:?}", accept_encoding2.items());
227
228 println!("\n3f. Practical example - Content negotiation:");
229 practical_content_negotiation_example();
230}More examples
examples/accept_encoding_preferred.rs (line 30)
11fn main() {
12 println!("=== AcceptEncoding Preferred and Sorting Examples ===\n");
13
14 // Create an AcceptEncoding with different quality values
15 let encodings = vec![
16 (Encoding::Gzip, 0.7),
17 (Encoding::Deflate, 0.9), // This should be preferred (highest quality)
18 (Encoding::Br, 1.0), // Highest quality, but might not be allowed by server
19 (Encoding::Identity, 0.1),
20 (Encoding::Zstd, 0.8), // High quality compression
21 ];
22
23 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
24
25 println!("Original encodings:");
26 print_encodings(&accept_encoding);
27
28 // Find preferred encoding from unsorted list
29 println!("\n1. Finding preferred encoding (unsorted) - preferred():");
30 if let Some(preferred) = accept_encoding.preferred() {
31 println!(
32 " Preferred: {} (finds highest quality from unsorted list)",
33 preferred
34 );
35 }
36
37 // Example server capabilities - let's say server only supports some encodings
38 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
39
40 println!("\n2. Server-side filtering with preferred_allowed():");
41 println!(" Server supports: {:?}", server_supported);
42 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
43 println!(
44 " Preferred (server filtered): {} (highest quality that server supports)",
45 preferred_allowed
46 );
47 }
48
49 // Compare different server capabilities
50 let limited_server = vec![Encoding::Identity]; // Very limited server
51 println!("\n Limited server supports only: {:?}", limited_server);
52 if let Some(preferred_limited) = accept_encoding.preferred_allowed(limited_server.iter()) {
53 println!(
54 " Preferred (limited server): {} (only available option)",
55 preferred_limited
56 );
57 } else {
58 println!(" No acceptable encoding found for limited server");
59 }
60
61 let advanced_server = vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip]; // Advanced server
62 println!("\n Advanced server supports: {:?}", advanced_server);
63 if let Some(preferred_advanced) = accept_encoding.preferred_allowed(advanced_server.iter()) {
64 println!(
65 " Preferred (advanced server): {} (best match from advanced capabilities)",
66 preferred_advanced
67 );
68 }
69
70 // Sort descending (highest quality first) - modifies in place
71 println!("\n3. After sorting descending (in-place):");
72 accept_encoding.sort_descending();
73 print_encodings(&accept_encoding);
74
75 if let Some(preferred) = accept_encoding.preferred() {
76 println!(
77 " Preferred: {} (first item when sorted descending)",
78 preferred
79 );
80 }
81
82 // Test preferred_allowed with sorted list
83 println!("\n Server-side filtering after sorting descending:");
84 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
85 println!(
86 " Preferred (server filtered): {} (efficiently finds first match in sorted list)",
87 preferred_allowed
88 );
89 }
90
91 // Sort ascending (lowest quality first) - modifies in place
92 println!("\n4. After sorting ascending (in-place):");
93 accept_encoding.sort_ascending();
94 print_encodings(&accept_encoding);
95
96 if let Some(preferred) = accept_encoding.preferred() {
97 println!(
98 " Preferred: {} (last item when sorted ascending)",
99 preferred
100 );
101 }
102
103 // Test preferred_allowed with ascending sorted list
104 println!("\n Server-side filtering after sorting ascending:");
105 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
106 println!(
107 " Preferred (server filtered): {} (efficiently finds best match from end)",
108 preferred_allowed
109 );
110 }
111
112 // Demonstrate chaining - sort methods return &mut Self for chaining
113 println!("\n5. Method chaining example:");
114 let encodings2 = vec![
115 (Encoding::Gzip, 0.3),
116 (Encoding::Deflate, 0.8),
117 (Encoding::Br, 0.6),
118 ];
119
120 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
121
122 // Chain operations
123 let preferred_after_desc_sort = accept_encoding2.sort_descending().preferred().cloned(); // Clone the encoding to avoid borrowing issues
124
125 println!(
126 " After chaining sort_descending().preferred(): {:?}",
127 preferred_after_desc_sort
128 );
129
130 // Sort back and get preferred
131 let preferred_after_asc_sort = accept_encoding2.sort_ascending().preferred().cloned();
132
133 println!(
134 " After chaining sort_ascending().preferred(): {:?}",
135 preferred_after_asc_sort
136 );
137
138 // Demonstrate with equal quality values
139 println!("\n6. Equal quality values example:");
140 let equal_encodings = vec![
141 (Encoding::Gzip, 0.8),
142 (Encoding::Deflate, 0.8), // Same quality
143 (Encoding::Br, 0.8), // Same quality
144 ];
145
146 let mut equal_accept = AcceptEncoding::new(equal_encodings).unwrap();
147 println!(" Original (all equal quality):");
148 print_encodings(&equal_accept);
149
150 if let Some(preferred) = equal_accept.preferred() {
151 println!(
152 " Preferred from equal qualities: {} (first found with max quality)",
153 preferred
154 );
155 }
156
157 // Test server filtering with equal qualities
158 let partial_server = vec![Encoding::Deflate, Encoding::Br];
159 if let Some(preferred_filtered) = equal_accept.preferred_allowed(partial_server.iter()) {
160 println!(
161 " Preferred (server filtered from equal qualities): {} (first allowed match)",
162 preferred_filtered
163 );
164 }
165
166 equal_accept.sort_descending();
167 println!(" After sort_descending (stable sort preserves original order for equal elements):");
168 print_encodings(&equal_accept);
169
170 // Demonstrate practical content negotiation scenario
171 println!("\n7. Practical content negotiation scenario:");
172 practical_negotiation_example();
173}
174
175fn print_encodings(accept_encoding: &AcceptEncoding) {
176 for (encoding, quality) in accept_encoding.items() {
177 println!(" {} (q={})", encoding, quality);
178 }
179}
180
181/// Demonstrates practical content negotiation comparing both methods
182fn practical_negotiation_example() {
183 println!(
184 " Scenario: Client sends 'Accept-Encoding: br;q=1.0, zstd;q=0.9, gzip;q=0.7, deflate;q=0.5'"
185 );
186
187 let client_preferences = vec![
188 (Encoding::Br, 1.0), // Client's top choice
189 (Encoding::Zstd, 0.9), // Second choice
190 (Encoding::Gzip, 0.7), // Third choice
191 (Encoding::Deflate, 0.5), // Fallback
192 ];
193
194 let accept_encoding = AcceptEncoding::new(client_preferences).unwrap();
195
196 // Method 1: preferred() - ignores server capabilities
197 if let Some(client_preferred) = accept_encoding.preferred() {
198 println!(
199 " preferred(): {} (client's top choice, ignoring server)",
200 client_preferred
201 );
202 }
203
204 // Different server scenarios
205 let scenarios = vec![
206 (
207 "Basic server",
208 vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity],
209 ),
210 (
211 "Advanced server",
212 vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip],
213 ),
214 ("Legacy server", vec![Encoding::Deflate, Encoding::Identity]),
215 (
216 "Modern server",
217 vec![
218 Encoding::Br,
219 Encoding::Zstd,
220 Encoding::Gzip,
221 Encoding::Deflate,
222 ],
223 ),
224 ];
225
226 for (server_name, server_caps) in scenarios {
227 print!(" {}: supports {:?}", server_name, server_caps);
228
229 if let Some(negotiated) = accept_encoding.preferred_allowed(server_caps.iter()) {
230 println!(" → selected: {}", negotiated);
231 } else {
232 println!(" → no acceptable encoding found");
233 }
234 }
235
236 println!("\n Key difference:");
237 println!(" - preferred(): Returns client's top choice regardless of server capabilities");
238 println!(" - preferred_allowed(): Returns best mutually supported encoding");
239 println!(" - Both methods honor the current sorting state for efficiency");
240}Sourcepub fn preferred_allowed<'a>(
&'a self,
allowed: impl Iterator<Item = &'a Encoding>,
) -> Option<&'a Encoding>
pub fn preferred_allowed<'a>( &'a self, allowed: impl Iterator<Item = &'a Encoding>, ) -> Option<&'a Encoding>
Returns the highest-preference encoding that is also present in allowed.
Honors current sorting state (Ascending/Descending/Unsorted) like preferred.
Examples found in repository?
examples/accept_encoding_preferred.rs (line 42)
11fn main() {
12 println!("=== AcceptEncoding Preferred and Sorting Examples ===\n");
13
14 // Create an AcceptEncoding with different quality values
15 let encodings = vec![
16 (Encoding::Gzip, 0.7),
17 (Encoding::Deflate, 0.9), // This should be preferred (highest quality)
18 (Encoding::Br, 1.0), // Highest quality, but might not be allowed by server
19 (Encoding::Identity, 0.1),
20 (Encoding::Zstd, 0.8), // High quality compression
21 ];
22
23 let mut accept_encoding = AcceptEncoding::new(encodings).unwrap();
24
25 println!("Original encodings:");
26 print_encodings(&accept_encoding);
27
28 // Find preferred encoding from unsorted list
29 println!("\n1. Finding preferred encoding (unsorted) - preferred():");
30 if let Some(preferred) = accept_encoding.preferred() {
31 println!(
32 " Preferred: {} (finds highest quality from unsorted list)",
33 preferred
34 );
35 }
36
37 // Example server capabilities - let's say server only supports some encodings
38 let server_supported = vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity];
39
40 println!("\n2. Server-side filtering with preferred_allowed():");
41 println!(" Server supports: {:?}", server_supported);
42 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
43 println!(
44 " Preferred (server filtered): {} (highest quality that server supports)",
45 preferred_allowed
46 );
47 }
48
49 // Compare different server capabilities
50 let limited_server = vec![Encoding::Identity]; // Very limited server
51 println!("\n Limited server supports only: {:?}", limited_server);
52 if let Some(preferred_limited) = accept_encoding.preferred_allowed(limited_server.iter()) {
53 println!(
54 " Preferred (limited server): {} (only available option)",
55 preferred_limited
56 );
57 } else {
58 println!(" No acceptable encoding found for limited server");
59 }
60
61 let advanced_server = vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip]; // Advanced server
62 println!("\n Advanced server supports: {:?}", advanced_server);
63 if let Some(preferred_advanced) = accept_encoding.preferred_allowed(advanced_server.iter()) {
64 println!(
65 " Preferred (advanced server): {} (best match from advanced capabilities)",
66 preferred_advanced
67 );
68 }
69
70 // Sort descending (highest quality first) - modifies in place
71 println!("\n3. After sorting descending (in-place):");
72 accept_encoding.sort_descending();
73 print_encodings(&accept_encoding);
74
75 if let Some(preferred) = accept_encoding.preferred() {
76 println!(
77 " Preferred: {} (first item when sorted descending)",
78 preferred
79 );
80 }
81
82 // Test preferred_allowed with sorted list
83 println!("\n Server-side filtering after sorting descending:");
84 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
85 println!(
86 " Preferred (server filtered): {} (efficiently finds first match in sorted list)",
87 preferred_allowed
88 );
89 }
90
91 // Sort ascending (lowest quality first) - modifies in place
92 println!("\n4. After sorting ascending (in-place):");
93 accept_encoding.sort_ascending();
94 print_encodings(&accept_encoding);
95
96 if let Some(preferred) = accept_encoding.preferred() {
97 println!(
98 " Preferred: {} (last item when sorted ascending)",
99 preferred
100 );
101 }
102
103 // Test preferred_allowed with ascending sorted list
104 println!("\n Server-side filtering after sorting ascending:");
105 if let Some(preferred_allowed) = accept_encoding.preferred_allowed(server_supported.iter()) {
106 println!(
107 " Preferred (server filtered): {} (efficiently finds best match from end)",
108 preferred_allowed
109 );
110 }
111
112 // Demonstrate chaining - sort methods return &mut Self for chaining
113 println!("\n5. Method chaining example:");
114 let encodings2 = vec![
115 (Encoding::Gzip, 0.3),
116 (Encoding::Deflate, 0.8),
117 (Encoding::Br, 0.6),
118 ];
119
120 let mut accept_encoding2 = AcceptEncoding::new(encodings2).unwrap();
121
122 // Chain operations
123 let preferred_after_desc_sort = accept_encoding2.sort_descending().preferred().cloned(); // Clone the encoding to avoid borrowing issues
124
125 println!(
126 " After chaining sort_descending().preferred(): {:?}",
127 preferred_after_desc_sort
128 );
129
130 // Sort back and get preferred
131 let preferred_after_asc_sort = accept_encoding2.sort_ascending().preferred().cloned();
132
133 println!(
134 " After chaining sort_ascending().preferred(): {:?}",
135 preferred_after_asc_sort
136 );
137
138 // Demonstrate with equal quality values
139 println!("\n6. Equal quality values example:");
140 let equal_encodings = vec![
141 (Encoding::Gzip, 0.8),
142 (Encoding::Deflate, 0.8), // Same quality
143 (Encoding::Br, 0.8), // Same quality
144 ];
145
146 let mut equal_accept = AcceptEncoding::new(equal_encodings).unwrap();
147 println!(" Original (all equal quality):");
148 print_encodings(&equal_accept);
149
150 if let Some(preferred) = equal_accept.preferred() {
151 println!(
152 " Preferred from equal qualities: {} (first found with max quality)",
153 preferred
154 );
155 }
156
157 // Test server filtering with equal qualities
158 let partial_server = vec![Encoding::Deflate, Encoding::Br];
159 if let Some(preferred_filtered) = equal_accept.preferred_allowed(partial_server.iter()) {
160 println!(
161 " Preferred (server filtered from equal qualities): {} (first allowed match)",
162 preferred_filtered
163 );
164 }
165
166 equal_accept.sort_descending();
167 println!(" After sort_descending (stable sort preserves original order for equal elements):");
168 print_encodings(&equal_accept);
169
170 // Demonstrate practical content negotiation scenario
171 println!("\n7. Practical content negotiation scenario:");
172 practical_negotiation_example();
173}
174
175fn print_encodings(accept_encoding: &AcceptEncoding) {
176 for (encoding, quality) in accept_encoding.items() {
177 println!(" {} (q={})", encoding, quality);
178 }
179}
180
181/// Demonstrates practical content negotiation comparing both methods
182fn practical_negotiation_example() {
183 println!(
184 " Scenario: Client sends 'Accept-Encoding: br;q=1.0, zstd;q=0.9, gzip;q=0.7, deflate;q=0.5'"
185 );
186
187 let client_preferences = vec![
188 (Encoding::Br, 1.0), // Client's top choice
189 (Encoding::Zstd, 0.9), // Second choice
190 (Encoding::Gzip, 0.7), // Third choice
191 (Encoding::Deflate, 0.5), // Fallback
192 ];
193
194 let accept_encoding = AcceptEncoding::new(client_preferences).unwrap();
195
196 // Method 1: preferred() - ignores server capabilities
197 if let Some(client_preferred) = accept_encoding.preferred() {
198 println!(
199 " preferred(): {} (client's top choice, ignoring server)",
200 client_preferred
201 );
202 }
203
204 // Different server scenarios
205 let scenarios = vec![
206 (
207 "Basic server",
208 vec![Encoding::Gzip, Encoding::Deflate, Encoding::Identity],
209 ),
210 (
211 "Advanced server",
212 vec![Encoding::Br, Encoding::Zstd, Encoding::Gzip],
213 ),
214 ("Legacy server", vec![Encoding::Deflate, Encoding::Identity]),
215 (
216 "Modern server",
217 vec![
218 Encoding::Br,
219 Encoding::Zstd,
220 Encoding::Gzip,
221 Encoding::Deflate,
222 ],
223 ),
224 ];
225
226 for (server_name, server_caps) in scenarios {
227 print!(" {}: supports {:?}", server_name, server_caps);
228
229 if let Some(negotiated) = accept_encoding.preferred_allowed(server_caps.iter()) {
230 println!(" → selected: {}", negotiated);
231 } else {
232 println!(" → no acceptable encoding found");
233 }
234 }
235
236 println!("\n Key difference:");
237 println!(" - preferred(): Returns client's top choice regardless of server capabilities");
238 println!(" - preferred_allowed(): Returns best mutually supported encoding");
239 println!(" - Both methods honor the current sorting state for efficiency");
240}Sourcepub fn preferred_allowed_weighted<'a>(
&'a self,
allowed: impl Iterator<Item = (&'a Encoding, QualityValue)>,
) -> Option<&'a Encoding>
pub fn preferred_allowed_weighted<'a>( &'a self, allowed: impl Iterator<Item = (&'a Encoding, QualityValue)>, ) -> Option<&'a Encoding>
Returns the highest-preference encoding that is also present in allowed,
taking into account both client preferences and server weights.
When multiple encodings have the same weight, the one with highest
allowed weight is chosen.
Trait Implementations§
Source§impl Clone for AcceptEncoding
impl Clone for AcceptEncoding
Source§fn clone(&self) -> AcceptEncoding
fn clone(&self) -> AcceptEncoding
Returns a duplicate of the value. Read more
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moreAuto Trait Implementations§
impl Freeze for AcceptEncoding
impl RefUnwindSafe for AcceptEncoding
impl Send for AcceptEncoding
impl Sync for AcceptEncoding
impl Unpin for AcceptEncoding
impl UnwindSafe for AcceptEncoding
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more