Function encode_header_value 

pub fn encode_header_value(
    encodings: &[(Encoding, QualityValue)],
) -> Result<String, AcceptEncodingEncodeError>

Encodes a list of encodings with quality values into Accept-Encoding header value

Examples found in repository

examples/basic_usage.rs (line 44)

fn accept_encoding_examples() {
    println!("1. Accept-Encoding Header Examples");
    println!("==================================");

    // Example 1a: Encoding Accept-Encoding header values
    println!("\n1a. Encoding Accept-Encoding header values:");
    let encodings = vec![
        (Encoding::Gzip, 1.0),
        (Encoding::Deflate, 0.8),
        (Encoding::Br, 0.6),
        (Encoding::Identity, 0.1),
    ];

    match encode_header_value(&encodings) {
        Ok(header_value) => {
            println!("   Input: {:?}", encodings);
            println!("   Encoded header: {}", header_value);
        }
        Err(e) => println!("   Error encoding: {}", e),
    }

    // Example 1b: Decoding Accept-Encoding header values
    println!("\n1b. Decoding Accept-Encoding header values:");
    let header_string = "gzip, deflate;q=0.8, br;q=0.6, identity;q=0.1";
    println!("   Input header: {}", header_string);

    match decode_header_value(header_string) {
        Ok(parsed) => {
            println!("   Decoded encodings:");
            for (encoding, quality) in parsed {
                println!("     {} (q={})", encoding, quality);
            }
        }
        Err(e) => println!("   Error decoding: {}", e),
    }

    // Example 1c: Working with complex Accept-Encoding values
    println!("\n1c. Complex Accept-Encoding example:");
    let complex_header = "gzip;q=1.0, deflate;q=0.5, br;q=0.25, *;q=0.1";
    println!("   Input: {}", complex_header);

    if let Ok(parsed) = decode_header_value(complex_header) {
        // Create AcceptEncoding instance
        if let Ok(accept_encoding) = AcceptEncoding::new(parsed) {
            println!(
                "   Created AcceptEncoding with {} encodings",
                accept_encoding.items().len()
            );

            // Re-encode it
            if let Ok(re_encoded) = encode_header_value(accept_encoding.items()) {
                println!("   Re-encoded: {}", re_encoded);
            }
        }
    }
}

examples/encode_decode.rs (line 43)

fn accept_encoding_encode_decode_examples() {
    println!("1. Accept-Encoding Encode/Decode");
    println!("=================================");

    // Example 1: Basic encoding
    println!("\n1a. Basic encoding:");
    let encodings = vec![
        (Encoding::Gzip, 1.0),
        (Encoding::Deflate, 0.8),
        (Encoding::Br, 0.6),
    ];

    match encode_header_value(&encodings) {
        Ok(encoded) => println!("   Encoded: {}", encoded),
        Err(e) => println!("   Error: {}", e),
    }

    // Example 2: Encoding with quality value formatting
    println!("\n1b. Quality value formatting:");
    let encodings_with_various_qualities = vec![
        (Encoding::Gzip, 1.0),       // q=1.0 omitted
        (Encoding::Deflate, 0.500),  // trailing zeros trimmed
        (Encoding::Br, 0.123),       // precise value
        (Encoding::Identity, 0.100), // trailing zeros trimmed
    ];

    match encode_header_value(&encodings_with_various_qualities) {
        Ok(encoded) => {
            println!("   Input qualities: [1.0, 0.500, 0.123, 0.100]");
            println!("   Encoded: {}", encoded);
            println!("   (Note: q=1.0 omitted, trailing zeros trimmed)");
        }
        Err(e) => println!("   Error: {}", e),
    }

    // Example 3: Basic decoding
    println!("\n1c. Basic decoding:");
    let header_values = vec![
        "gzip",
        "gzip, deflate",
        "gzip, deflate;q=0.8, br;q=0.6",
        "br;q=1.0, gzip;q=0.8, deflate;q=0.5, *;q=0.1",
    ];

    for header in header_values {
        println!("   Decoding: \"{}\"", header);
        match decode_header_value(header) {
            Ok(parsed) => {
                println!("   Result:");
                for (encoding, quality) in parsed {
                    println!("     {} (q={})", encoding, quality);
                }
            }
            Err(e) => println!("   Error: {}", e),
        }
        println!();
    }

    // Example 4: Round-trip encoding/decoding
    println!("1d. Round-trip encoding/decoding:");
    let original = vec![
        (Encoding::Gzip, 1.0),
        (Encoding::Deflate, 0.8),
        (Encoding::Custom("custom-encoding".to_string()), 0.5),
    ];

    println!("   Original: {:?}", original);

    if let Ok(encoded) = encode_header_value(&original) {
        println!("   Encoded: {}", encoded);

        if let Ok(decoded) = decode_header_value(&encoded) {
            println!("   Decoded: {:?}", decoded);

            // Verify they match
            let matches = original.len() == decoded.len()
                && original
                    .iter()
                    .zip(decoded.iter())
                    .all(|((enc1, q1), (enc2, q2))| enc1 == enc2 && (q1 - q2).abs() < f32::EPSILON);
            println!("   Round-trip successful: {}", matches);
        }
    }
}

#[cfg(feature = "http_crates")]
fn content_encoding_examples() {
    println!("\n\n2. Content-Encoding Examples");
    println!("============================");

    // Example 1: Creating Content-Encoding
    println!("\n2a. Creating Content-Encoding headers:");
    let encodings_to_test = vec![
        Encoding::Gzip,
        Encoding::Deflate,
        Encoding::Br,
        Encoding::Zstd,
        Encoding::Custom("lz4".to_string()),
    ];

    for encoding in encodings_to_test {
        let content_encoding = ContentEncoding::new(encoding);
        println!("   Created: {:?}", content_encoding);

        // Encode to header value
        let mut values = Vec::new();
        content_encoding.encode(&mut values);

        if let Some(header_value) = values.first() {
            if let Ok(as_str) = header_value.to_str() {
                println!("     Header value: {}", as_str);
            }
        }
    }

    // Example 2: Decoding Content-Encoding headers
    println!("\n2b. Decoding Content-Encoding headers:");
    let test_headers = vec!["gzip", "deflate", "br", "zstd", "custom-encoding"];

    for header_str in test_headers {
        println!("   Decoding: \"{}\"", header_str);

        let header_values = vec![HeaderValue::from_str(header_str).unwrap()];
        match ContentEncoding::decode(&mut header_values.iter()) {
            Ok(decoded) => {
                println!("     Success: {:?}", decoded);
                println!("     Encoding: {:?}", decoded.encoding());
            }
            Err(e) => println!("     Error: {:?}", e),
        }
    }
}

#[cfg(not(feature = "http_crates"))]
fn content_encoding_examples() {
    println!("\n\n2. Content-Encoding Examples");
    println!("============================");
    println!("   (Skipped - http_crates feature not enabled)");
}

fn error_handling_examples() {
    println!("\n\n3. Error Handling Examples");
    println!("==========================");

    // Example 1: Encoding errors
    println!("\n3a. Accept-Encoding encoding errors:");

    // Empty encodings list
    match encode_header_value(&[]) {
        Ok(_) => println!("   Unexpected success"),
        Err(AcceptEncodingEncodeError::EmptyEncodings) => {
            println!("   ✓ Correctly caught empty encodings error");
        }
        Err(_) => println!("   Unexpected error type"),
    }

    // Example 2: Decoding errors
    println!("\n3b. Accept-Encoding decoding errors:");

    let invalid_headers = vec![
        "",               // Empty string
        " , gzip",        // Empty encoding name
        ";q=1.0",         // Missing encoding name
        "gzip;q=invalid", // Invalid quality value
        "gzip;foo=bar",   // Unknown directive
    ];

    for invalid_header in invalid_headers {
        println!("   Testing: \"{}\"", invalid_header);
        match decode_header_value(invalid_header) {
            Ok(_) => println!("     Unexpected success"),
            Err(AcceptEncodingDecodeError::EmptyEncodingName) => {
                println!("     ✓ Empty encoding name error");
            }
            Err(AcceptEncodingDecodeError::EmptyEncodingWeightTuple) => {
                println!("     ✓ Empty encoding weight tuple error");
            }
            Err(AcceptEncodingDecodeError::InvalidQualityValue(val)) => {
                println!("     ✓ Invalid quality value error: {}", val);
            }
            Err(AcceptEncodingDecodeError::UnexpectedDirective(directive)) => {
                println!("     ✓ Unexpected directive error: {}", directive);
            }
            Err(_) => println!("     ✓ Other decode error"),
        }
    }

    #[cfg(feature = "http_crates")]
    {
        // Example 3: Content-Encoding conflicting values
        println!("\n3c. Content-Encoding conflicting values:");
        let conflicting = vec![
            HeaderValue::from_str("gzip").unwrap(),
            HeaderValue::from_str("deflate").unwrap(),
        ];

        match ContentEncoding::decode(&mut conflicting.iter()) {
            Ok(_) => println!("   Unexpected success"),
            Err(_) => println!("   ✓ Correctly rejected conflicting Content-Encoding values"),
        }
    }
}