h2 0.4.20

An HTTP/2 client and server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::hpack::huffman::table::{ENCODE_CODES, ENCODE_CODE_LENGTHS};

use bytes::{BufMut, BytesMut};

pub fn encode(src: &[u8], dst: &mut BytesMut) {
    let mut bits = 0u64;
    let mut bits_len = 0;

    for &b in src {
        let nbits = ENCODE_CODE_LENGTHS[b as usize] as usize;
        let code = ENCODE_CODES[b as usize] as u64;

        bits = (bits << nbits) | code;
        bits_len += nbits;

        if bits_len >= 32 {
            let remaining = bits_len - 32;
            dst.put_u32((bits >> remaining) as u32);

            bits_len = remaining;
            if remaining == 0 {
                bits = 0;
            } else {
                bits &= (1 << remaining) - 1;
            }
        }
    }

    if bits_len != 0 {
        // Pad the final byte with the EOS prefix (all ones).
        let padding = 8 - (bits_len % 8);
        let padding = if padding == 8 { 0 } else { padding };
        bits = (bits << padding) | ((1 << padding) - 1);
        bits_len += padding;

        while bits_len != 0 {
            bits_len -= 8;
            dst.put_u8((bits >> bits_len) as u8);
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn encode_single_byte() {
        let mut dst = BytesMut::with_capacity(1);

        encode(b"o", &mut dst);
        assert_eq!(&dst[..], &[0b00111111]);

        dst.clear();
        encode(b"0", &mut dst);
        assert_eq!(&dst[..], &[7]);

        dst.clear();
        encode(b"A", &mut dst);
        assert_eq!(&dst[..], &[(0x21 << 2) + 3]);
    }

    #[test]
    fn encode_rfc_example() {
        let mut dst = BytesMut::new();

        encode(b"www.example.com", &mut dst);

        assert_eq!(
            &dst[..],
            &[0xf1, 0xe3, 0xc2, 0xe5, 0xf2, 0x3a, 0x6b, 0xa0, 0xab, 0x90, 0xf4, 0xff]
        );
    }
}

/*
// uncomment to run benchmarks
#[cfg(test)]
mod bench {
    extern crate test;

    use self::test::{black_box, Bencher};
    use super::*;

    fn encode_input(b: &mut Bencher, input: &[u8]) {
        let mut encoded = BytesMut::new();
        encode(input, &mut encoded);

        b.bytes = input.len() as u64;
        b.iter(|| {
            encoded.clear();
            encode(black_box(input), &mut encoded);
            black_box(encoded.as_ref());
        });
    }

    #[bench]
    fn encode_short_ascii(b: &mut Bencher) {
        encode_input(b, b"www.example.com");
    }

    #[bench]
    fn encode_header_value(b: &mut Bencher) {
        encode_input(
            b,
            b"text/html,application/xhtml+xml,application/xml;q=0.9;q=0.8",
        );
    }

    #[bench]
    fn encode_long_ascii(b: &mut Bencher) {
        encode_input(
            b,
            b"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) Gecko/20100101 Firefox/16.0",
        );
    }

    #[bench]
    fn encode_all_octets(b: &mut Bencher) {
        let input: Vec<_> = (0..=u8::MAX).collect();
        encode_input(b, &input);
    }
}
*/