rosu-render 0.5.1

An o!rdr wrapper to render osu! replays
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

use std::str::from_utf8 as str_from_utf8;

use bytes::{BufMut, Bytes, BytesMut};
use itoa::Buffer;

use super::error::WebsocketError;

#[derive(Copy, Clone, Debug)]
#[repr(u8)]
pub(super) enum PacketKind {
    Connect = 0,
    Disconnect = 1,
    Event = 2,
    Ack = 3,
    ConnectError = 4,
}

impl TryFrom<char> for PacketKind {
    type Error = WebsocketError;

    fn try_from(value: char) -> Result<Self, Self::Error> {
        match value {
            '0' => Ok(PacketKind::Connect),
            '1' => Ok(PacketKind::Disconnect),
            '2' => Ok(PacketKind::Event),
            '3' => Ok(PacketKind::Ack),
            '4' => Ok(PacketKind::ConnectError),
            _ => Err(WebsocketError::InvalidPacketId(value)),
        }
    }
}

#[derive(Debug)]
pub(super) struct Packet {
    pub kind: PacketKind,
    pub data: Option<Bytes>,
    pub id: Option<i32>,
}

impl Default for Packet {
    fn default() -> Self {
        Self {
            kind: PacketKind::Event,
            data: None,
            id: None,
        }
    }
}

impl Packet {
    pub(super) fn new(kind: PacketKind, id: Option<i32>) -> Self {
        Self {
            kind,
            data: None,
            id,
        }
    }

    pub(super) fn new_ack(id: i32) -> Self {
        Self {
            kind: PacketKind::Ack,
            data: Some(Bytes::from_static(b"[]")),
            id: Some(id),
        }
    }

    pub(super) fn to_bytes(&self) -> Bytes {
        let mut bytes = BytesMut::new();
        bytes.put_u8(self.kind as u8 + b'0');

        if let Some(id) = self.id {
            let mut itoa_buf = Buffer::new();
            bytes.extend_from_slice(itoa_buf.format(id).as_bytes());
        }

        if let Some(data) = self.data.as_ref() {
            bytes.extend_from_slice(data);
        }

        bytes.freeze()
    }

    pub(super) fn from_bytes(bytes: &Bytes) -> Result<Self, WebsocketError> {
        let mut payload = str_from_utf8(bytes).map_err(WebsocketError::InvalidUtf8)?;
        let mut packet = Packet::default();

        let id_char = payload
            .chars()
            .next()
            .ok_or(WebsocketError::InvalidPacket)?;

        packet.kind = PacketKind::try_from(id_char)?;
        payload = &payload[id_char.len_utf8()..];

        if payload.starts_with('/') {
            let (_, rest) = payload
                .split_once(',')
                .ok_or(WebsocketError::InvalidPacket)?;

            payload = rest;
        }

        let Some((non_digit_idx, _)) = payload.char_indices().find(|(_, c)| !c.is_ascii_digit()) else {
            return Ok(packet);
        };

        if non_digit_idx > 0 {
            let (prefix, rest) = payload.split_at(non_digit_idx);
            payload = rest;
            packet.id = Some(prefix.parse().map_err(|_| WebsocketError::InvalidPacket)?);
        }

        packet.data = Some(bytes.slice_ref(payload.as_bytes()));

        Ok(packet)
    }
}