1use crate::{serialization::{deserialize::{Deserialize, Deserializer}, serialize::{Serialize, Serializer}}, transfer::base64::{decode, encode_into}};
2
3pub struct JsonSerde<'a> {
4 buffer: String,
5 stack: Vec<Group<'a>>,
6 read_index: usize
7}
8
9#[derive(Default)]
10struct Group<'a> {
11 delimiter: Delimiter,
12 item_placed: bool,
13 is_key: bool,
14 is_struct: bool,
15 keys: &'a [&'a str],
16 current_key: usize
17}
18
19#[derive(PartialEq, Eq)]
20enum Delimiter {
21 Object,
22 Array
23}
24
25impl Default for Delimiter {
26 fn default() -> Self {
27 Self::Array
28 }
29}
30
31impl<'a> JsonSerde<'a> {
32 fn new(buffer: Option<String>) -> Self {
33 Self {
34 buffer: match buffer {
35 Some(buf) => buf,
36 None => String::new()
37 },
38 stack: Vec::new(),
39 read_index: 0
40 }
41 }
42
43 fn read_prim(&mut self) -> Result<&str, String> {
44 self.skip_whitespace();
45 self.skip_field_name();
46
47 if let Some(c) = self.buffer[self.read_index..].chars().next() {
48 if c == ':' {
49 self.read_index += 1;
50 }
51 }
52
53 let mut read_to: usize = 0;
54 for c in self.buffer.chars().skip(self.read_index) {
55 if c == ',' || c == ']' || c == '}' {
56 break;
57 }
58 else {
59 read_to += 1;
60 }
61 }
62
63 if self.buffer.len() < self.read_index + read_to {
64 return Err("JsonSerde: Deserialization out of bounds".to_string());
65 }
66 let slice = &self.buffer[self.read_index..self.read_index + read_to];
67 self.read_index += read_to;
68
69 if let Some(c) = self.buffer[self.read_index..].chars().next() {
70 if c == ',' {
71 self.read_index += 1;
72 }
73 }
74
75 Ok(slice)
76 }
77
78 fn count_items(&self) -> usize {
79 let mut count: usize = 0;
80 let mut depth: usize = 0;
81 let mut character_escaped = false;
82 let mut in_string = false;
83 let mut has_items = false;
84 for c in self.buffer.chars().skip(self.read_index) {
85 if c == '\\' {
86 character_escaped = true;
87 }
88 else if !character_escaped && c == '"' {
89 character_escaped = false;
90 in_string = !in_string;
91 }
92 else if c == '[' || c == '{' {
93 if depth == 1 {
94 has_items = true;
95 }
96 depth += 1;
97 }
98 else if depth == 0 {
99 break;
100 }
101 else if c == ']' || c == '}' {
102 depth -= 1;
103 }
104 else if depth == 1 && !in_string && c == ',' {
105 count += 1;
106 }
107 else if depth == 1 && c != ' ' {
108 has_items = true;
109 }
110
111 }
112 if has_items || count > 0 {
113 count += 1;
114 }
115
116 count
117 }
118
119 fn skip_whitespace(&mut self) {
120 for c in self.buffer.chars().skip(self.read_index) {
121 if c == ' ' {
122 self.read_index += 1;
123 }
124 else {
125 break;
126 }
127 }
128 }
129
130 fn skip_field_name(&mut self) {
131 if let Some(group) = self.stack.last() {
132 if group.is_struct {
133 let mut character_escaped = false;
134 self.read_index += 1;
135 for c in self.buffer.chars().skip(self.read_index) {
136 if c == '\\' {
137 self.read_index += 1;
138 character_escaped = true;
139 continue;
140 }
141 else if !character_escaped && c == '"' {
142 self.read_index += 1;
143 break;
144 }
145 else {
146 self.read_index += 1;
147 character_escaped = false;
148 }
149 }
150 self.skip_whitespace();
151 self.read_index += 1;
152 }
153 }
154 }
155
156 fn format_element(&mut self) {
157 if let Some(group) = self.stack.last_mut() {
158 if group.is_struct {
159 if group.item_placed {
160 self.buffer.push_str(&format!(",\"{}\":", group.keys[group.current_key]));
161 }
162 else {
163 self.buffer.push_str(&format!("\"{}\":", group.keys[group.current_key]));
164 group.item_placed = true;
165 }
166 group.current_key += 1;
167 }
168 else if group.item_placed {
169 if group.delimiter == Delimiter::Object {
170 if group.is_key {
171 self.buffer.push(',');
172 group.is_key = false;
173 }
174 else {
175 self.buffer.push(':');
176 group.is_key = true;
177 }
178 }
179 else if group.delimiter == Delimiter::Array {
180 self.buffer.push(',');
181 }
182 }
183 else {
184 group.item_placed = true;
185 }
186 }
187 }
188
189 pub fn serialize<T: Serialize<'a>>(item: &T) -> Result<String, String> {
190 let mut serde = JsonSerde::new(None);
191 item.serialize(&mut serde);
192 Ok(serde.buffer.clone())
193 }
194
195 pub fn deserialize<T: Deserialize>(buffer: String) -> Result<T, String> {
196 let mut serde = JsonSerde::new(Some(buffer));
197 Ok(T::deserialize(&mut serde)?)
198 }
199}
200
201impl<'a> Serializer<'a> for JsonSerde<'a> {
202 fn write_u8(&mut self, n: u8) {
203 self.format_element();
204 if self.stack.last().unwrap().is_key {
205 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
206 }
207 else {
208 self.buffer.push_str(&n.to_string());
209 }
210 }
211
212 fn write_u16(&mut self, n: u16) {
213 self.format_element();
214 if self.stack.last().unwrap().is_key {
215 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
216 }
217 else {
218 self.buffer.push_str(&n.to_string());
219 }
220 }
221
222 fn write_u32(&mut self, n: u32) {
223 self.format_element();
224 if self.stack.last().unwrap().is_key {
225 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
226 }
227 else {
228 self.buffer.push_str(&n.to_string());
229 }
230 }
231
232 fn write_u64(&mut self, n: u64) {
233 self.format_element();
234 if self.stack.last().unwrap().is_key {
235 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
236 }
237 else {
238 self.buffer.push_str(&n.to_string());
239 }
240 }
241
242 fn write_u128(&mut self, n: u128) {
243 self.format_element();
244 if self.stack.last().unwrap().is_key {
245 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
246 }
247 else {
248 self.buffer.push_str(&n.to_string());
249 }
250 }
251
252 fn write_i8(&mut self, n: i8) {
253 self.format_element();
254 if self.stack.last().unwrap().is_key {
255 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
256 }
257 else {
258 self.buffer.push_str(&n.to_string());
259 }
260 }
261
262 fn write_i16(&mut self, n: i16) {
263 self.format_element();
264 if self.stack.last().unwrap().is_key {
265 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
266 }
267 else {
268 self.buffer.push_str(&n.to_string());
269 }
270 }
271
272 fn write_i32(&mut self, n: i32) {
273 self.format_element();
274 if self.stack.last().unwrap().is_key {
275 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
276 }
277 else {
278 self.buffer.push_str(&n.to_string());
279 }
280 }
281
282 fn write_i64(&mut self, n: i64) {
283 self.format_element();
284 if self.stack.last().unwrap().is_key {
285 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
286 }
287 else {
288 self.buffer.push_str(&n.to_string());
289 }
290 }
291
292 fn write_i128(&mut self, n: i128) {
293 self.format_element();
294 if self.stack.last().unwrap().is_key {
295 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
296 }
297 else {
298 self.buffer.push_str(&n.to_string());
299 }
300 }
301
302 fn write_f32(&mut self, n: f32) {
303 self.format_element();
304 if self.stack.last().unwrap().is_key {
305 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
306 }
307 else {
308 self.buffer.push_str(&n.to_string());
309 }
310 }
311
312 fn write_f64(&mut self, n: f64) {
313 self.format_element();
314 if self.stack.last().unwrap().is_key {
315 self.buffer.push_str(&format!("\"{}\"", n.to_string()));
316 }
317 else {
318 self.buffer.push_str(&n.to_string());
319 }
320 }
321
322 fn write_bool(&mut self, b: bool) {
323 self.format_element();
324 if self.stack.last().unwrap().is_key {
325 self.buffer.push_str(&format!("\"{}\"", b.to_string()));
326 }
327 else {
328 self.buffer.push_str(&b.to_string());
329 }
330 }
331
332 fn write_bytes(&mut self, bytes: &[u8]) {
333 self.format_element();
334 self.buffer.push('"');
335 encode_into(bytes, &mut self.buffer);
336 self.buffer.push('"');
337 }
338
339 fn write_string(&mut self, s: &str) {
340 self.format_element();
341 self.buffer.push('"');
342 for c in s.chars() {
343 if c == '"' || c == '\\' {
344 self.buffer.push('\\');
345 self.buffer.push(c);
346 }
347 else {
348 self.buffer.push(c);
349 }
350 }
351 self.buffer.push('"');
352 }
353
354 fn write_seq<F>(&mut self, _len: usize, f: F)
355 where F: FnOnce(&mut Self) {
356 if let Some(group) = self.stack.last() {
357 if group.delimiter == Delimiter::Object && group.is_key {
358 panic!("JsonSerde: JSON keys must be primitives or strings, tried to use a sequence as a key");
359 }
360 }
361 self.format_element();
362 self.buffer.push('[');
363 self.stack.push(Group {
364 delimiter: Delimiter::Array,
365 item_placed: false,
366 is_key: false,
367 is_struct: false,
368 keys: &[],
369 current_key: 0
370 });
371 f(self);
372 self.stack.pop();
373 self.buffer.push(']');
374 }
375
376 fn write_map<F>(&mut self, _len: usize, f: F)
377 where F: FnOnce(&mut Self) {
378 if let Some(group) = self.stack.last() {
379 if group.delimiter == Delimiter::Object && group.is_key {
380 panic!("JsonSerde: JSON keys must be primitives or strings, tried to use a map as a key");
381 }
382 }
383 self.format_element();
384 self.buffer.push('{');
385 self.stack.push(Group {
386 delimiter: Delimiter::Object,
387 item_placed: false,
388 is_key: true,
389 is_struct: false,
390 keys: &[],
391 current_key: 0
392 });
393 f(self);
394 self.stack.pop();
395 self.buffer.push('}');
396 }
397
398 fn write_tuple<F>(&mut self, _len: usize, f: F)
399 where F: FnOnce(&mut Self) {
400 if let Some(group) = self.stack.last() {
401 if group.delimiter == Delimiter::Object && group.is_key {
402 panic!("JsonSerde: JSON keys must be primitives or strings, tried to use a tuple as a key");
403 }
404 }
405 self.format_element();
406 self.buffer.push('[');
407 self.stack.push(Group {
408 delimiter: Delimiter::Array,
409 item_placed: false,
410 is_key: false,
411 is_struct: false,
412 keys: &[],
413 current_key: 0
414 });
415 f(self);
416 self.stack.pop();
417 self.buffer.push(']');
418 }
419
420 fn write_struct<F>(&mut self, _name: &str, fields: &'a [&'a str], f: F)
421 where F: FnOnce(&mut Self) {
422 if let Some(group) = self.stack.last() {
423 if group.delimiter == Delimiter::Object && group.is_key {
424 panic!("JsonSerde: JSON keys must be primitives or strings, tried to use a struct as a key");
425 }
426 }
427 self.format_element();
428 self.buffer.push('{');
429 self.stack.push(Group {
430 delimiter: Delimiter::Object,
431 item_placed: false,
432 is_key: false,
433 is_struct: true,
434 keys: fields,
435 current_key: 0
436 });
437 f(self);
438 self.stack.pop();
439 self.buffer.push('}');
440 }
441
442 fn write_enum<F>(&mut self, _enum_name: &str, _variant_index: u32, variant_name: &'a [&'a str], f: F)
443 where F: FnOnce(&mut Self) {
444 if let Some(group) = self.stack.last() {
445 if group.delimiter == Delimiter::Object && group.is_key {
446 panic!("JsonSerde: JSON keys must be primitives or strings, tried to use an enum as a key");
447 }
448 }
449 self.format_element();
450 self.buffer.push('{');
451 self.buffer.push_str(&format!("\"{}\"", variant_name[0]));
452 self.stack.push(Group {
453 delimiter: Delimiter::Object,
454 item_placed: true,
455 is_key: false,
456 is_struct: false,
457 keys: variant_name,
458 current_key: 0
459 });
460 f(self);
461 self.stack.pop();
462 self.buffer.push('}');
463 }
464}
465
466impl<'a> Deserializer for JsonSerde<'a> {
467 fn read_u8(&mut self) -> Result<u8, String> {
468 Ok(self.read_prim()?.parse::<u8>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
469 }
470
471 fn read_u16(&mut self) -> Result<u16, String> {
472 Ok(self.read_prim()?.parse::<u16>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
473 }
474
475 fn read_u32(&mut self) -> Result<u32, String> {
476 Ok(self.read_prim()?.parse::<u32>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
477 }
478
479 fn read_u64(&mut self) -> Result<u64, String> {
480 Ok(self.read_prim()?.parse::<u64>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
481 }
482
483 fn read_u128(&mut self) -> Result<u128, String> {
484 Ok(self.read_prim()?.parse::<u128>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
485 }
486
487 fn read_i8(&mut self) -> Result<i8, String> {
488 Ok(self.read_prim()?.parse::<i8>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
489 }
490
491 fn read_i16(&mut self) -> Result<i16, String> {
492 Ok(self.read_prim()?.parse::<i16>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
493 }
494
495 fn read_i32(&mut self) -> Result<i32, String> {
496 Ok(self.read_prim()?.parse::<i32>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
497 }
498
499 fn read_i64(&mut self) -> Result<i64, String> {
500 Ok(self.read_prim()?.parse::<i64>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
501 }
502
503 fn read_i128(&mut self) -> Result<i128, String> {
504 Ok(self.read_prim()?.parse::<i128>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
505 }
506
507 fn read_f32(&mut self) -> Result<f32, String> {
508 Ok(self.read_prim()?.parse::<f32>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
509 }
510
511 fn read_f64(&mut self) -> Result<f64, String> {
512 Ok(self.read_prim()?.parse::<f64>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
513 }
514
515 fn read_bool(&mut self) -> Result<bool, String> {
516 Ok(self.read_prim()?.parse::<bool>().map_err(|e| format!("JsonSerde: Deserialization error: {}", e))?)
517 }
518
519 fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
520 Ok(decode(self.read_string()?))
521 }
522
523 fn read_string(&mut self) -> Result<String, String> {
524 self.skip_whitespace();
525 self.skip_field_name();
526
527 if let Some(c) = self.buffer[self.read_index..].chars().next() {
528 if c == ':' {
529 self.read_index += 1;
530 }
531 }
532
533 let mut string = String::new();
534 let mut character_escaped = false;
535 self.read_index += 1;
536 for c in self.buffer.chars().skip(self.read_index) {
537 if c == '\\' {
538 self.read_index += 1;
539 character_escaped = true;
540 continue;
541 }
542 else if !character_escaped && c == '"' {
543 self.read_index += 1;
544 break;
545 }
546 else {
547 self.read_index += 1;
548 character_escaped = false;
549 string.push(c);
550 }
551 }
552
553 if let Some(c) = self.buffer[self.read_index..].chars().next() {
554 if c == ',' {
555 self.read_index += 1;
556 }
557 }
558
559 Ok(string)
560 }
561
562 fn read_seq<F, T>(&mut self, f: F) -> Result<T, String>
563 where F: FnOnce(&mut Self, usize) -> Result<T, String> {
564 self.skip_whitespace();
565 self.skip_field_name();
566 self.stack.push(Group::default());
567 let item_count = self.count_items();
568 self.read_index += 1;
569 let seq = f(self, item_count)?;
570 self.read_index += 1;
571 if let Some(c) = self.buffer[self.read_index..].chars().next() {
572 if c == ',' {
573 self.read_index += 1;
574 }
575 }
576 self.stack.pop();
577
578 Ok(seq)
579 }
580
581 fn read_map<F, T>(&mut self, f: F) -> Result<T, String>
582 where F: FnOnce(&mut Self, usize) -> Result<T, String> {
583 self.skip_whitespace();
584 self.skip_field_name();
585 self.stack.push(Group::default());
586 let item_count = self.count_items();
587 self.read_index += 1;
588 let map = f(self, item_count)?;
589 self.read_index += 1;
590 if let Some(c) = self.buffer[self.read_index..].chars().next() {
591 if c == ',' {
592 self.read_index += 1;
593 }
594 }
595 self.stack.pop();
596
597 Ok(map)
598 }
599
600 fn read_tuple<F, T>(&mut self, _len: usize, f: F) -> Result<T, String>
601 where F: FnOnce(&mut Self) -> Result<T, String> {
602 self.skip_whitespace();
603 self.skip_field_name();
604 self.stack.push(Group::default());
605 self.read_index += 1;
606 let seq = f(self)?;
607 self.read_index += 1;
608 if let Some(c) = self.buffer[self.read_index..].chars().next() {
609 if c == ',' {
610 self.read_index += 1;
611 }
612 }
613 self.stack.pop();
614
615 Ok(seq)
616 }
617
618 fn read_struct<F, T>(&mut self, _name: &str, _fields: &[&str], f: F) -> Result<T, String>
619 where F: FnOnce(&mut Self) -> Result<T, String> {
620 self.skip_whitespace();
621 self.skip_field_name();
622 self.stack.push(Group { is_struct: true, ..Default::default() });
623 self.read_index += 1;
624 let obj = f(self)?;
625 self.read_index += 1;
626 if let Some(c) = self.buffer[self.read_index..].chars().next() {
627 if c == ',' {
628 self.read_index += 1;
629 }
630 }
631 self.stack.pop();
632
633 Ok(obj)
634 }
635
636 fn read_enum<F, T>(&mut self, _enum_name: &str, variants: &[&str], f: F) -> Result<T, String>
637 where F: FnOnce(&mut Self, u32) -> Result<T, String> {
638 self.skip_whitespace();
639 self.skip_field_name();
640 self.stack.push(Group::default());
641 self.read_index += 1;
642 let var_name = self.read_string()?;
643 if let Some(c) = self.buffer[self.read_index..].chars().next() {
644 if c == ':' {
645 self.read_index += 1;
646 }
647 }
648 let var = match variants.iter().enumerate().find(|(_, s)| *s == &var_name) {
649 Some(var) => var,
650 None => return Err("JsonSerde: Variant name not found in possible variants".to_string())
651 };
652 let obj = f(self, var.0 as u32)?;
653 self.read_index += 1;
654 if let Some(c) = self.buffer[self.read_index..].chars().next() {
655 if c == ',' {
656 self.read_index += 1;
657 }
658 }
659 self.stack.pop();
660
661 Ok(obj)
662 }
663}