derive-rs 0.1.16

Rust SDK for Derive.xyz
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
125

#[inline(always)]
pub fn extract_id_tail(bytes: &[u8]) -> Option<u64> {
    let mut i = bytes.len();

    // Trim trailing whitespace
    while i > 0 {
        match bytes[i - 1] {
            b' ' | b'\t' | b'\n' | b'\r' => i -= 1,
            _ => break,
        }
    }

    // Expect final '}' (JSON object end) but tolerate if caller trimmed it earlier
    if i == 0 {
        return None;
    }
    if bytes[i - 1] == b'}' {
        i -= 1;
    }

    // Trim whitespace before digits
    while i > 0 {
        match bytes[i - 1] {
            b' ' | b'\t' | b'\n' | b'\r' => i -= 1,
            _ => break,
        }
    }

    // Parse digits backwards: ... "id":123
    let mut val: u64 = 0;
    let mut mul: u64 = 1;
    let mut ndigits = 0usize;

    while i > 0 {
        let b = bytes[i - 1];
        if b.is_ascii_digit() {
            val = val.wrapping_add(((b - b'0') as u64).wrapping_mul(mul));
            mul = mul.wrapping_mul(10);
            ndigits += 1;
            i -= 1;
        } else {
            break;
        }
    }

    if ndigits == 0 {
        return None;
    }

    // Trim whitespace before ':'
    while i > 0 {
        match bytes[i - 1] {
            b' ' | b'\t' | b'\n' | b'\r' => i -= 1,
            _ => break,
        }
    }

    // Expect ':' before the digits
    if i == 0 || bytes[i - 1] != b':' {
        return None;
    }
    i -= 1;

    // Trim whitespace before the key
    while i > 0 {
        match bytes[i - 1] {
            b' ' | b'\t' | b'\n' | b'\r' => i -= 1,
            _ => break,
        }
    }

    // Expect `"id"` immediately before ':'
    // bytes[..i] ends right before the key
    if i < 4 {
        return None;
    }
    // Check for ... " i d "
    if bytes[i - 4] != b'"' || bytes[i - 3] != b'i' || bytes[i - 2] != b'd' || bytes[i - 1] != b'"'
    {
        return None;
    }

    Some(val)
}

#[inline(always)]
pub fn extract_id(bytes: &[u8]) -> Option<u64> {
    // Quick check: does it start with "{"id":"
    if !bytes.starts_with(b"{\"id\":") {
        return None;
    }

    // Start parsing after `"id":`
    let mut i = 6; // skip {"id":
    let start = i;

    // parse digits
    while let Some(&b) = bytes.get(i) {
        if !b.is_ascii_digit() {
            break;
        }
        i += 1;
    }

    std::str::from_utf8(&bytes[start..i]).ok()?.parse().ok()
}

#[inline(always)]
pub fn extract_channel(bytes: &[u8]) -> Option<&str> {
    if !bytes.starts_with(b"{\"method\":\"subscription\"") {
        return None;
    }
    let mut i = 46;
    let start = i;

    while i < bytes.len() {
        let b = bytes[i];
        if b == b'"' {
            break;
        }
        i += 1;
    }

    unsafe { Some(std::str::from_utf8_unchecked(&bytes[start..i])) }
}