1. 1#[derive(Debug, Clone, PartialEq, Eq)]
2. 2pub struct SseFrame {
3. 3 pub event: Option<String>,
4. 4 pub data: String,
5. 5}
6. 6
7. 7#[derive(Debug, Default)]
8. 8pub struct SseDecoder {
9. 9 buf: Vec<u8>,
10. 10 cursor: usize,
11. 11 pending_event: Option<String>,
12. 12 pending_data: Option<String>,
13. 13}
14. 14
15. 15impl SseDecoder {
16. 16 pub fn new() -> Self {
17. 17 Self::default()
18. 18 }
19. 19
20. 20 pub fn push(&mut self, chunk: &[u8]) {
21. 21 self.buf.extend_from_slice(chunk);
22. 22 }
23. 23
24. 24 pub fn next_frame(&mut self) -> Option<SseFrame> {
25. 25 loop {
26. 26 let Some(nl) = self.buf[self.cursor..].iter().position(|&b| b == b'\n') else {
27. 27 self.compact();
28. 28 return None;
29. 29 };
30. 30 let line_start = self.cursor;
31. 31 let line_end = self.cursor + nl;
32. 32 let mut line = &self.buf[line_start..line_end];
33. 33 if line.last() == Some(&b'\r') {
34. 34 line = &line[..line.len() - 1];
35. 35 }
36. 36 self.cursor = line_end + 1;
37. 37
38. 38 if line.is_empty() {
39. 39 let had_content = self.pending_event.is_some() || self.pending_data.is_some();
40. 40 if !had_content {
41. 41 continue;
42. 42 }
43. 43 let frame = SseFrame {
44. 44 event: self.pending_event.take(),
45. 45 data: self.pending_data.take().unwrap_or_default(),
46. 46 };
47. 47 self.compact();
48. 48 return Some(frame);
49. 49 }
50. 50
51. 51 if line[0] == b':' {
52. 52 continue;
53. 53 }
54. 54 let (field, value) = match line.iter().position(|&b| b == b':') {
55. 55 Some(colon) => {
56. 56 let mut v = &line[colon + 1..];
57. 57 if v.first() == Some(&b' ') {
58. 58 v = &v[1..];
59. 59 }
60. 60 (&line[..colon], v)
61. 61 }
62. 62 None => (line, &b""[..]),
63. 63 };
64. 64 match field {
65. 65 b"event" => {
66. 66 if let Ok(name) = std::str::from_utf8(value) {
67. 67 self.pending_event = Some(name.to_string());
68. 68 }
69. 69 }
70. 70 b"data" => {
71. 71 if let Ok(text) = std::str::from_utf8(value) {
72. 72 match &mut self.pending_data {
73. 73 Some(existing) => {
74. 74 existing.push('\n');
75. 75 existing.push_str(text);
76. 76 }
77. 77 None => self.pending_data = Some(text.to_string()),
78. 78 }
79. 79 }
80. 80 }
81. 81 _ => {}
82. 82 }
83. 83 }
84. 84 }
85. 85
86. 86 fn compact(&mut self) {
87. 87 if self.cursor > 0 {
88. 88 self.buf.drain(..self.cursor);
89. 89 self.cursor = 0;
90. 90 }
91. 91 }
92. 92}
93. 93