Struct Encoder 

pub struct Encoder { /* private fields */ }

A QPACK encoder.

Implementations

impl Encoder

pub fn new() -> Self

Creates a new encoder.

If not configured, this encoder will only make use of a static table.

Once peer’s settings has been received, you might want to allocate the dynamic table by means of Self::configure.

Examples found in repository

examples/simple.rs (line 8)

fn main() {
    let (encoded_headers, _) = Encoder::new()
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    let decoded_headers = Decoder::new(0, 0)
        .decode(StreamId::new(0), encoded_headers)
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_headers);
}

examples/dyn_table.rs (line 8)

fn main() {
    let mut encoder = Encoder::new();
    let sdtc_data = encoder.configure(1024, 1024, 1).unwrap();

    let (encoded_hdr_data, encoded_stream_data) = encoder
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    println!("Encoding ratio: {}", encoder.ratio());

    let mut decoder = Decoder::new(1024, 1);
    decoder.feed(sdtc_data).unwrap();

    let decoder_status = decoder.decode(StreamId::new(0), encoded_hdr_data).unwrap();

    assert!(decoder_status.is_blocked());
    println!("Decoder blocked. Stream data needed");

    decoder.feed(encoded_stream_data).unwrap();

    let decoded_hdr = decoder
        .unblocked(StreamId::new(0))
        .unwrap()
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_hdr);
}

pub fn configure( &mut self, max_table_size: u32, dyn_table_size: u32, max_blocked_streams: u32, ) -> Result<SDTCInstruction, EncoderError>

Sets dynamic table size and it applies peer’s settings.

Returns

SDTC instruction (Set Dynamic Table Capacity) data. This should be transmitted to the peer via encoder stream.

Notes

• dyn_table_size can be 0 to avoid dynamic table.
• dyn_table_size cannot be larger than max_table_size.

Examples found in repository

examples/dyn_table.rs (line 9)

fn main() {
    let mut encoder = Encoder::new();
    let sdtc_data = encoder.configure(1024, 1024, 1).unwrap();

    let (encoded_hdr_data, encoded_stream_data) = encoder
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    println!("Encoding ratio: {}", encoder.ratio());

    let mut decoder = Decoder::new(1024, 1);
    decoder.feed(sdtc_data).unwrap();

    let decoder_status = decoder.decode(StreamId::new(0), encoded_hdr_data).unwrap();

    assert!(decoder_status.is_blocked());
    println!("Decoder blocked. Stream data needed");

    decoder.feed(encoded_stream_data).unwrap();

    let decoded_hdr = decoder
        .unblocked(StreamId::new(0))
        .unwrap()
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_hdr);
}

pub fn encode_all<I, H>( &mut self, stream_id: StreamId, headers: I, ) -> Result<BuffersEncoded, EncoderError>

where I: IntoIterator<Item = H>, H: TryIntoHeader,

Encodes an entire header block (a list of headers).

Returns

The encoded data (see BuffersEncoded).

Examples

use ls_qpack::encoder::Encoder;
use ls_qpack::StreamId;

let mut encoder = Encoder::new();
let (enc_hdr, enc_stream) = encoder
    .encode_all(
        StreamId::new(0),
        [(":status", "404"), (":method", "connect")],
    )
    .unwrap()
    .into();

Examples found in repository

examples/simple.rs (line 9)

fn main() {
    let (encoded_headers, _) = Encoder::new()
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    let decoded_headers = Decoder::new(0, 0)
        .decode(StreamId::new(0), encoded_headers)
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_headers);
}

examples/dyn_table.rs (line 12)

fn main() {
    let mut encoder = Encoder::new();
    let sdtc_data = encoder.configure(1024, 1024, 1).unwrap();

    let (encoded_hdr_data, encoded_stream_data) = encoder
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    println!("Encoding ratio: {}", encoder.ratio());

    let mut decoder = Decoder::new(1024, 1);
    decoder.feed(sdtc_data).unwrap();

    let decoder_status = decoder.decode(StreamId::new(0), encoded_hdr_data).unwrap();

    assert!(decoder_status.is_blocked());
    println!("Decoder blocked. Stream data needed");

    decoder.feed(encoded_stream_data).unwrap();

    let decoded_hdr = decoder
        .unblocked(StreamId::new(0))
        .unwrap()
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_hdr);
}

pub fn encoding(&mut self, stream_id: StreamId) -> EncodingBlock<'_>

Encodes a list of headers in a sequential fashion way.

This method is similar to Self::encode_all. However, instead of providing the entire list of header, it is possible to append a header step by step.

See EncodingBlock.

Examples

use ls_qpack::encoder::Encoder;
use ls_qpack::StreamId;

let mut encoder = Encoder::new();
let mut encoding_block = encoder.encoding(StreamId::new(0));

encoding_block.append((":status", "404"));
encoding_block.append((":method", "connect"));

let (enc_hdr, enc_stream) = encoding_block.encode().unwrap().into();

pub fn ratio(&self) -> f32

Return estimated compression ratio until this point.

Compression ratio is defined as size of the output divided by the size of the input, where output includes both header blocks and instructions sent on the encoder stream.

Examples found in repository

examples/dyn_table.rs (line 16)

fn main() {
    let mut encoder = Encoder::new();
    let sdtc_data = encoder.configure(1024, 1024, 1).unwrap();

    let (encoded_hdr_data, encoded_stream_data) = encoder
        .encode_all(StreamId::new(0), HEADERS)
        .unwrap()
        .into();

    println!("Encoding ratio: {}", encoder.ratio());

    let mut decoder = Decoder::new(1024, 1);
    decoder.feed(sdtc_data).unwrap();

    let decoder_status = decoder.decode(StreamId::new(0), encoded_hdr_data).unwrap();

    assert!(decoder_status.is_blocked());
    println!("Decoder blocked. Stream data needed");

    decoder.feed(encoded_stream_data).unwrap();

    let decoded_hdr = decoder
        .unblocked(StreamId::new(0))
        .unwrap()
        .unwrap()
        .take()
        .unwrap();

    println!("Decoded header: {:?}", decoded_hdr);
}

Trait Implementations

impl Default for Encoder

fn default() -> Self

Returns the “default value” for a type.