Struct Decoder 

pub struct Decoder { /* private fields */ }

A QPACK decoder.

Implementations

impl Decoder

pub fn new(dyn_table_size: u32, max_blocked_streams: u32) -> Self

Creates a new decoder.

Specify the size of the dynamic table (it might be 0). And the max number of blocked streams.

Examples found in repository

examples/simple.rs (line 13)

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 18)

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 decode<D>( &mut self, stream_id: StreamId, data: D, ) -> Result<DecoderOutput, DecoderError>

where D: AsRef<[u8]>,

Decodes header data.

It produces an output, see DecoderOutput.

It might happen that the data provided to this method are not sufficient in order to complete the decoding operation. In that case, more data are needed from the encoder stream (via Decoder::feed).

Examples

use ls_qpack::decoder::Decoder;
use ls_qpack::StreamId;



let mut decoder = Decoder::new(0, 0);
let output = decoder.decode(StreamId::new(0), data).unwrap();

Examples found in repository

examples/simple.rs (line 14)

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 21)

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 feed<D>(&mut self, data: D) -> Result<(), DecoderError>

where D: AsRef<[u8]>,

Feeds data from encoder’s buffer stream.

Examples found in repository

examples/dyn_table.rs (line 19)

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 unblocked( &mut self, stream_id: StreamId, ) -> Option<Result<DecoderOutput, DecoderError>>

Checks whether a header block for a StreamId has become unblocked.

Returns

• None if the StreamId has never been fed.
• Some if the StreamId produced an DecoderOutput.

Examples found in repository

examples/dyn_table.rs (line 29)

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);
}