Struct hpack::encoder::Encoder

pub struct Encoder<'a> { /* fields omitted */ }

Represents an HPACK encoder. Allows clients to encode arbitrary header sets and tracks the encoding context. That is, encoding subsequent header sets will use the context built by previous encode calls.

This is the main API for performing HPACK encoding of headers.

Examples

Encoding a header two times in a row produces two different representations, due to the utilization of HPACK compression.

use hpack::Encoder;

let mut encoder = Encoder::new();

let headers = vec![
    (b"custom-key".to_vec(), b"custom-value".to_vec()),
];
// First encoding...
let result = encoder.encode(&headers);
// The result is a literal encoding of the header name and value, with an
// initial byte representing the type of the encoding
// (incremental indexing).
assert_eq!(
    vec![0x40,
         10, b'c', b'u', b's', b't', b'o', b'm', b'-', b'k', b'e', b'y',
         12, b'c', b'u', b's', b't', b'o', b'm', b'-', b'v', b'a', b'l',
         b'u', b'e'],
    result);

// Encode the same headers again!
let result = encoder.encode(&headers);
// The result is simply the index of the header in the header table (62),
// with a flag representing that the decoder should use the index.
assert_eq!(vec![0x80 | 62], result);

Methods

impl<'a> Encoder<'a>

pub fn new() -> Encoder<'a>

Creates a new Encoder with a default static table, as defined by the HPACK spec (Appendix A).

pub fn encode(&mut self, headers: &Vec<(Vec<u8>, Vec<u8>)>) -> Vec<u8>

Encodes the given headers using the HPACK rules and returns a newly allocated Vec containing the bytes representing the encoded header set.

The encoder so far supports only a single, extremely simple encoding strategy, whereby each header is represented as an indexed header if already found in the header table and a literal otherwise. When a header isn't found in the table, it is added if the header name wasn't found either (i.e. there are never two header names with different values in the produced header table). Strings are always encoded as literals (Huffman encoding is not used).