rammux 0.1.2

Asynchronous stream multiplexer
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

use std::fmt;

use crate::{
    StreamId,
    buffer::{Buffer, Data},
    header::{ControlFlags, PingPayload, RawHeader},
};

pub enum DecoderState {
    ReadingHeader {
        filled: usize,
        buffer: [u8; RawHeader::LEN],
    },
    ReadingData {
        stream_id: StreamId,
        flags: ControlFlags,
        buffer: Buffer,
        filled: usize,
    },
}

impl Default for DecoderState {
    fn default() -> Self {
        Self::ReadingHeader {
            filled: 0,
            buffer: [0; RawHeader::LEN],
        }
    }
}

#[derive(Debug, PartialEq, Eq)]
pub enum DecodedFrame {
    Ping {
        payload: PingPayload,
        is_response: bool,
    },
    Stream {
        stream_id: StreamId,
        flags: ControlFlags,
        payload: StreamPayload,
    },
    Terminate,
}

#[derive(PartialEq, Eq)]
pub enum StreamPayload {
    WindowUpdate(u32),
    Data(Data),
}

impl fmt::Debug for StreamPayload {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::WindowUpdate(update) => f.debug_tuple("WindowUpdate").field(update).finish(),
            Self::Data(data) => f.debug_tuple("Data").field(&data.as_ref().len()).finish(),
        }
    }
}