makepad_micro_serde/
serde_ron.rs

1use std::collections::HashMap;
2use std::hash::Hash;
3use std::str::Chars;
4
5pub struct SerRonState {
6    pub out: String
7}
8
9impl SerRonState {
10    pub fn indent(&mut self, d: usize) {
11        for _ in 0..d {
12            self.out.push_str("    ");
13        }
14    }
15    
16    pub fn field(&mut self, d: usize, field: &str) {
17        self.indent(d);
18        self.out.push_str(field);
19        self.out.push(':');
20    }
21    
22    pub fn conl(&mut self) {
23        self.out.push_str(",\n")
24    }
25    
26    pub fn st_pre(&mut self) {
27        self.out.push_str("(\n");
28    }
29    
30    pub fn st_post(&mut self, d: usize) {
31        self.indent(d);
32        self.out.push(')');
33    }
34    
35}
36
37pub trait SerRon {
38    
39    fn serialize_ron(&self) -> String {
40        let mut s = SerRonState {
41            out: String::new()
42        };
43        self.ser_ron(0, &mut s);
44        s.out
45    }
46    
47    fn ser_ron(&self, d: usize, s: &mut SerRonState);
48}
49
50pub trait DeRon: Sized {
51    
52    fn deserialize_ron(input: &str) -> Result<Self,
53    DeRonErr> {
54        let mut state = DeRonState::default();
55        let mut chars = input.chars();
56        state.next(&mut chars);
57        state.next_tok(&mut chars) ?;
58        DeRon::de_ron(&mut state, &mut chars)
59    }
60    
61    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Self,
62    DeRonErr>;
63}
64
65#[derive(PartialEq, Debug)]
66#[derive(Default)]
67pub enum DeRonTok {
68    Ident,
69    Str,
70    U64(u64),
71    I64(i64),
72    F64(f64),
73    Bool(bool),
74    Char(char),
75    Colon,
76    CurlyOpen,
77    CurlyClose,
78    ParenOpen,
79    ParenClose,
80    BlockOpen,
81    BlockClose,
82    Comma,
83    #[default]
84    Bof,
85    Eof
86}
87
88
89
90#[derive(Default)]
91pub struct DeRonState {
92    pub cur: char,
93    pub tok: DeRonTok,
94    pub strbuf: String,
95    pub numbuf: String,
96    pub identbuf: String,
97    pub line: usize,
98    pub col: usize
99}
100
101pub struct DeRonErr {
102    pub msg: String,
103    pub line: usize,
104    pub col: usize
105}
106
107impl std::fmt::Debug for DeRonErr {
108    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
109        write!(f, "Ron Deserialize error: {}, line:{} col:{}", self.msg, self.line + 1, self.col + 1)
110    }
111}
112
113impl DeRonState {
114    pub fn next(&mut self, i: &mut Chars) {
115        if let Some(c) = i.next() {
116            self.cur = c;
117            if self.cur == '\n' {
118                self.line += 1;
119                self.col = 0;
120            }
121            else {
122                self.col = 0;
123            }
124        }
125        else {
126            self.cur = '\0';
127        }
128    }
129    
130    pub fn err_exp(&self, name: &str) -> DeRonErr {
131        DeRonErr {msg: format!("Unexpected key {}", name), line: self.line, col: self.col}
132    }
133    
134    pub fn err_nf(&self, name: &str) -> DeRonErr {
135        DeRonErr {msg: format!("Key not found {}", name), line: self.line, col: self.col}
136    }
137    
138    pub fn err_enum(&self, name: &str) -> DeRonErr {
139        DeRonErr {msg: format!("Enum not defined {}", name), line: self.line, col: self.col}
140    }
141    
142    pub fn err_token(&self, what: &str) -> DeRonErr {
143        DeRonErr {msg: format!("Unexpected token {:?} expected {} ", self.tok, what), line: self.line, col: self.col}
144    }
145    
146    pub fn err_range(&self, what: &str) -> DeRonErr {
147        DeRonErr {msg: format!("Value out of range {} ", what), line: self.line, col: self.col}
148    }
149    
150    pub fn err_type(&self, what: &str) -> DeRonErr {
151        DeRonErr {msg: format!("Token wrong type {} ", what), line: self.line, col: self.col}
152    }
153    
154    pub fn err_parse(&self, what: &str) -> DeRonErr {
155        DeRonErr {msg: format!("Cannot parse {} ", what), line: self.line, col: self.col}
156    }
157    
158    pub fn eat_comma_paren(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
159        match self.tok {
160            DeRonTok::Comma => {
161                self.next_tok(i) ?;
162                Ok(())
163            },
164            DeRonTok::ParenClose => {
165                Ok(())
166            }
167            _ => {
168                Err(self.err_token(", or )"))
169            }
170        }
171    }
172    
173    pub fn eat_comma_block(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
174        match self.tok {
175            DeRonTok::Comma => {
176                self.next_tok(i) ?;
177                Ok(())
178            },
179            DeRonTok::BlockClose => {
180                Ok(())
181            }
182            _ => {
183                Err(self.err_token(", or ]"))
184            }
185        }
186    }
187    
188    pub fn eat_comma_curly(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
189        match self.tok {
190            DeRonTok::Comma => {
191                self.next_tok(i) ?;
192                Ok(())
193            },
194            DeRonTok::CurlyClose => {
195                Ok(())
196            }
197            _ => {
198                Err(self.err_token(", or }"))
199            }
200        }
201    }
202    
203    pub fn colon(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
204        match self.tok {
205            DeRonTok::Colon => {
206                self.next_tok(i) ?;
207                Ok(())
208            },
209            _ => {
210                Err(self.err_token(":"))
211            }
212        }
213    }
214    
215    pub fn ident(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
216        match &mut self.tok {
217            DeRonTok::Ident => {
218                self.next_tok(i) ?;
219                Ok(())
220            },
221            _ => {
222                Err(self.err_token("Identifier"))
223            }
224        }
225    }
226    
227    pub fn next_colon(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
228        self.next_tok(i) ?;
229        self.colon(i) ?;
230        Ok(())
231    }
232    
233    pub fn next_ident(&mut self) -> Option<()> {
234        if let DeRonTok::Ident = &mut self.tok {
235            Some(())
236        }
237        else {
238            None
239        }
240    }
241    
242    pub fn paren_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
243        if self.tok == DeRonTok::ParenOpen {
244            self.next_tok(i) ?;
245            return Ok(())
246        }
247        Err(self.err_token("("))
248    }
249    
250    
251    pub fn paren_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
252        if self.tok == DeRonTok::ParenClose {
253            self.next_tok(i) ?;
254            return Ok(())
255        }
256        Err(self.err_token(")"))
257    }
258    
259    pub fn block_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
260        if self.tok == DeRonTok::BlockOpen {
261            self.next_tok(i) ?;
262            return Ok(())
263        }
264        Err(self.err_token("["))
265    }
266    
267    
268    pub fn block_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
269        if self.tok == DeRonTok::BlockClose {
270            self.next_tok(i) ?;
271            return Ok(())
272        }
273        Err(self.err_token("]"))
274    }
275    
276    pub fn curly_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
277        if self.tok == DeRonTok::CurlyOpen {
278            self.next_tok(i) ?;
279            return Ok(())
280        }
281        Err(self.err_token("{"))
282    }
283    
284    
285    pub fn curly_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
286        if self.tok == DeRonTok::CurlyClose {
287            self.next_tok(i) ?;
288            return Ok(())
289        }
290        Err(self.err_token("}"))
291    }
292    
293    
294    pub fn u64_range(&mut self, max: u64) -> Result<u64, DeRonErr> {
295        if let DeRonTok::U64(value) = self.tok {
296            if value > max {
297                return Err(self.err_range(&format!("{}>{}", value, max)))
298            }
299            return Ok(value)
300        }
301        Err(self.err_token("unsigned integer"))
302    }
303    
304    pub fn i64_range(&mut self, min: i64, max: i64) -> Result<i64, DeRonErr> {
305        if let DeRonTok::I64(value) = self.tok {
306            if value< min {
307                return Err(self.err_range(&format!("{}<{}", value, min)))
308            }
309            return Ok(value)
310        }
311        if let DeRonTok::U64(value) = self.tok {
312            if value as i64 > max {
313                return Err(self.err_range(&format!("{}>{}", value, max)))
314            }
315            return Ok(value as i64)
316        }
317        Err(self.err_token("signed integer"))
318    }
319    
320    pub fn as_f64(&mut self) -> Result<f64, DeRonErr> {
321        if let DeRonTok::I64(value) = self.tok {
322            return Ok(value as f64)
323        }
324        if let DeRonTok::U64(value) = self.tok {
325            return Ok(value as f64)
326        }
327        if let DeRonTok::F64(value) = self.tok {
328            return Ok(value)
329        }
330        Err(self.err_token("floating point"))
331    }
332    
333    pub fn as_bool(&mut self) -> Result<bool, DeRonErr> {
334        if let DeRonTok::Bool(value) = self.tok {
335            return Ok(value)
336        }
337        if let DeRonTok::U64(value) = self.tok {
338            return Ok(value != 0)
339        }
340        Err(self.err_token("boolean"))
341    }
342    
343    pub fn as_string(&mut self) -> Result<String, DeRonErr> {
344        if let DeRonTok::Str = &mut self.tok {
345            let mut val = String::new();
346            std::mem::swap(&mut val, &mut self.strbuf);
347            return Ok(val)
348        }
349        Err(self.err_token("string"))
350    }
351    
352    pub fn next_tok(&mut self, i: &mut Chars) -> Result<(), DeRonErr> {
353        loop {
354            while self.cur == '\n' || self.cur == '\r' || self.cur == '\t' || self.cur == ' ' {
355                self.next(i);
356            }
357            match self.cur {
358                '\0' => {
359                    self.tok = DeRonTok::Eof;
360                    return Ok(())
361                },
362                ':' => {
363                    self.next(i);
364                    self.tok = DeRonTok::Colon;
365                    return Ok(())
366                }
367                ',' => {
368                    self.next(i);
369                    self.tok = DeRonTok::Comma;
370                    return Ok(())
371                }
372                '[' => {
373                    self.next(i);
374                    self.tok = DeRonTok::BlockOpen;
375                    return Ok(())
376                }
377                ']' => {
378                    self.next(i);
379                    self.tok = DeRonTok::BlockClose;
380                    return Ok(())
381                }
382                '(' => {
383                    self.next(i);
384                    self.tok = DeRonTok::ParenOpen;
385                    return Ok(())
386                }
387                ')' => {
388                    self.next(i);
389                    self.tok = DeRonTok::ParenClose;
390                    return Ok(())
391                }
392                '{' => {
393                    self.next(i);
394                    self.tok = DeRonTok::CurlyOpen;
395                    return Ok(())
396                }
397                '}' => {
398                    self.next(i);
399                    self.tok = DeRonTok::CurlyClose;
400                    return Ok(())
401                }
402                '/' => {
403                    self.next(i);
404                    if self.cur == '/' { // single line comment
405                        while self.cur != '\0' {
406                            if self.cur == '\n' {
407                                self.next(i);
408                                break;
409                            }
410                            self.next(i);
411                        }
412                    }
413                    else if self.cur == '*' { // multline comment
414                        let mut last_star = false;
415                        while self.cur != '\0' {
416                            if self.cur == '/' && last_star {
417                                self.next(i);
418                                break;
419                            }
420                            last_star = self.cur == '*';
421                            self.next(i);
422                        }
423                    }
424                    else {
425                        return Err(self.err_parse("comment"));
426                    }
427                },
428                '-' | '0'..='9' => {
429                    self.numbuf.clear();
430                    let is_neg = if self.cur == '-' {
431                        self.numbuf.push(self.cur);
432                        self.next(i);
433                        true
434                    }
435                    else {
436                        false
437                    };
438                    while self.cur >= '0' && self.cur <= '9' {
439                        self.numbuf.push(self.cur);
440                        self.next(i);
441                    }
442                    if self.cur == '.' {
443                        self.numbuf.push(self.cur);
444                        self.next(i);
445                        while self.cur >= '0' && self.cur <= '9' {
446                            self.numbuf.push(self.cur);
447                            self.next(i);
448                        }
449                        if let Ok(num) = self.numbuf.parse() {
450                            self.tok = DeRonTok::F64(num);
451                            return Ok(())
452                        }
453                        else {
454                            return Err(self.err_parse("number"));
455                        }
456                    }
457                    else {
458                        if is_neg {
459                            if let Ok(num) = self.numbuf.parse() {
460                                self.tok = DeRonTok::I64(num);
461                                return Ok(())
462                            }
463                            else {
464                                return Err(self.err_parse("number"));
465                            }
466                        }
467                        if let Ok(num) = self.numbuf.parse() {
468                            self.tok = DeRonTok::U64(num);
469                            return Ok(())
470                        }
471                        else {
472                            return Err(self.err_parse("number"));
473                        }
474                    }
475                },
476                'a'..='z' | 'A'..='Z' | '_' => {
477                    self.identbuf.clear();
478                    while self.cur >= 'a' && self.cur <= 'z'
479                        || self.cur >= 'A' && self.cur <= 'Z'
480                        || self.cur == '_' {
481                        self.identbuf.push(self.cur);
482                        self.next(i);
483                    }
484                    if self.identbuf == "true" {
485                        self.tok = DeRonTok::Bool(true);
486                        return Ok(())
487                    }
488                    if self.identbuf == "false" {
489                        self.tok = DeRonTok::Bool(false);
490                        return Ok(())
491                    }
492                    self.tok = DeRonTok::Ident;
493                    return Ok(())
494                },
495                '\'' => {
496                    self.next(i);
497                    if self.cur == '\\' {
498                        self.next(i);
499                    }
500                    let chr = self.cur;
501                    self.next(i);
502                    if self.cur != '\'' {
503                        return Err(self.err_token("char"));
504                    }
505                    self.next(i);
506                    self.tok = DeRonTok::Char(chr);
507                },
508                '"' => {
509                    self.strbuf.clear();
510                    self.next(i);
511                    while self.cur != '"' {
512                        if self.cur == '\\' {
513                            self.next(i);
514                            match self.cur {
515                                'n' => self.strbuf.push('\n'),
516                                'r' => self.strbuf.push('\r'),
517                                't' => self.strbuf.push('\t'),
518                                '0' => self.strbuf.push('\0'),
519                                '\0' => {
520                                    return Err(self.err_parse("string"));
521                                },
522                                _ => self.strbuf.push(self.cur)
523                            }
524                            self.next(i);
525                        }
526                        else{
527                            if self.cur == '\0' {
528                                return Err(self.err_parse("string"));
529                            }
530                            self.strbuf.push(self.cur);
531                            self.next(i);
532                        }
533                    }
534                    self.next(i);
535                    self.tok = DeRonTok::Str;
536                    return Ok(())
537                },
538                _ => {
539                    return Err(self.err_token("tokenizer"));
540                }
541            }
542        }
543    }
544}
545
546macro_rules!impl_ser_de_ron_unsigned {
547    ( $ ty: ident, $ max: expr) => {
548        impl SerRon for $ ty {
549            fn ser_ron(&self, _d: usize, s: &mut SerRonState) {
550                s.out.push_str(&self.to_string());
551            }
552        }
553        
554        impl DeRon for $ ty {
555            fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty,
556            DeRonErr> {
557                //s.is_prefix(p, i) ?;
558                let val = s.u64_range( $ max as u64) ?;
559                s.next_tok(i) ?;
560                return Ok(val as $ ty);
561            }
562        }
563    }
564}
565
566macro_rules!impl_ser_de_ron_signed {
567    ( $ ty: ident, $ min: expr, $ max: expr) => {
568        impl SerRon for $ ty {
569            fn ser_ron(&self, _d: usize, s: &mut SerRonState) {
570                s.out.push_str(&self.to_string());
571            }
572        }
573        
574        impl DeRon for $ ty {
575            fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty,
576            DeRonErr> {
577                //s.is_prefix(p, i) ?;
578                let val = s.i64_range( $ min as i64, $ max as i64) ?;
579                s.next_tok(i) ?;
580                return Ok(val as $ ty);
581            }
582        }
583    }
584}
585
586macro_rules!impl_ser_de_ron_float {
587    ( $ ty: ident) => {
588        impl SerRon for $ ty {
589            fn ser_ron(&self, _d: usize, s: &mut SerRonState) {
590                s.out.push_str(&self.to_string());
591            }
592        }
593        
594        impl DeRon for $ ty {
595            fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty,
596            DeRonErr> {
597                //s.is_prefix(p, i) ?;
598                let val = s.as_f64() ?;
599                s.next_tok(i) ?;
600                return Ok(val as $ ty);
601            }
602        }
603    }
604}
605
606impl_ser_de_ron_unsigned!(usize, std::u64::MAX);
607impl_ser_de_ron_unsigned!(u64, std::u64::MAX);
608impl_ser_de_ron_unsigned!(u32, std::u32::MAX);
609impl_ser_de_ron_unsigned!(u16, std::u16::MAX);
610impl_ser_de_ron_unsigned!(u8, std::u8::MAX);
611impl_ser_de_ron_signed!(i64, std::i64::MIN, std::i64::MAX);
612impl_ser_de_ron_signed!(i32, std::i64::MIN, std::i64::MAX);
613impl_ser_de_ron_signed!(i16, std::i64::MIN, std::i64::MAX);
614impl_ser_de_ron_signed!(i8, std::i64::MIN, std::i8::MAX);
615impl_ser_de_ron_float!(f64);
616impl_ser_de_ron_float!(f32);
617
618impl<T> SerRon for Option<T> where T: SerRon {
619    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
620        if let Some(v) = self {
621            v.ser_ron(d, s);
622        }
623        else {
624            s.out.push_str("None");
625        }
626    }
627}
628
629impl<T> DeRon for Option<T> where T: DeRon {
630    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Self,
631    DeRonErr> {
632        if let DeRonTok::Ident = &s.tok {
633            if s.identbuf == "None" {
634                s.next_tok(i) ?;
635                return Ok(None)
636            }
637        }
638        Ok(Some(DeRon::de_ron(s, i) ?))
639    }
640}
641
642impl SerRon for bool {
643    fn ser_ron(&self, _d: usize, s: &mut SerRonState) {
644        if *self {
645            s.out.push_str("true")
646        }
647        else {
648            s.out.push_str("false")
649        }
650    }
651}
652
653impl DeRon for bool {
654    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<bool, DeRonErr> {
655        let val = s.as_bool() ?;
656        s.next_tok(i) ?;
657        Ok(val)
658    }
659}
660
661impl SerRon for String {
662    fn ser_ron(&self, _d: usize, s: &mut SerRonState) {
663        s.out.push('"');
664        for c in self.chars() {
665            match c {
666                '\n' => {s.out.push('\\'); s.out.push('n');},
667                '\r' => {s.out.push('\\'); s.out.push('r');},
668                '\t' => {s.out.push('\\'); s.out.push('t');},
669                '\0' => {s.out.push('\\'); s.out.push('0');},
670                '\\' => {s.out.push('\\'); s.out.push('\\');},
671                '"' => {s.out.push('\\'); s.out.push('"');},
672                _ => s.out.push(c)
673            }
674        }
675        s.out.push('"');
676    }
677}
678
679impl DeRon for String {
680    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<String, DeRonErr> {
681        let val = s.as_string() ?;
682        s.next_tok(i) ?;
683        Ok(val)
684    }
685}
686
687impl<T> SerRon for Vec<T> where T: SerRon {
688    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
689        s.out.push_str("[\n");
690        for item in self {
691            s.indent(d + 1);
692            item.ser_ron(d + 1, s);
693            s.conl();
694        }
695        s.indent(d);
696        s.out.push(']');
697    }
698}
699
700impl<T> DeRon for Vec<T> where T: DeRon {
701    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Vec<T>, DeRonErr> {
702        let mut out = Vec::new();
703        s.block_open(i) ?;
704        
705        while s.tok != DeRonTok::BlockClose {
706            out.push(DeRon::de_ron(s, i) ?);
707            s.eat_comma_block(i) ?;
708        }
709        s.block_close(i) ?;
710        Ok(out)
711    }
712}
713
714impl<T> SerRon for [T] where T: SerRon {
715    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
716        s.out.push('(');
717        let last = self.len() - 1;
718        for (index, item) in self.iter().enumerate() {
719            item.ser_ron(d + 1, s);
720            if index != last {
721                s.out.push_str(", ");
722            }
723        }
724        s.out.push(')');
725    }
726}
727
728unsafe fn de_ron_array_impl_inner<T>(top: *mut T, count: usize, s: &mut DeRonState, i: &mut Chars) -> Result<(), DeRonErr> where T: DeRon {
729    s.paren_open(i) ?;
730    for c in 0..count {
731        top.add(c).write(DeRon::de_ron(s, i) ?);
732        s.eat_comma_paren(i) ?;
733    }
734    s.paren_close(i) ?;
735    Ok(())
736}
737
738impl<T, const N: usize> DeRon for [T; N] where T: DeRon {
739    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Self,
740    DeRonErr> {
741        unsafe {
742            let mut to = std::mem::MaybeUninit::<[T; N]>::uninit();
743            let top: *mut T = &mut to as *mut _ as *mut T;
744            de_ron_array_impl_inner(top, N, s, i) ?;
745            Ok(to.assume_init())
746        }
747    }
748}
749
750fn de_ron_comma_paren<T>(s: &mut DeRonState, i: &mut Chars) -> Result<T, DeRonErr> where T: DeRon {
751    let t = DeRon::de_ron(s, i);
752    s.eat_comma_paren(i) ?;
753    t
754}
755
756impl<A, B> SerRon for (A, B) where A: SerRon,
757B: SerRon {
758    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
759        s.out.push('(');
760        self.0.ser_ron(d, s);
761        s.out.push_str(", ");
762        self.1.ser_ron(d, s);
763        s.out.push(')');
764    }
765}
766
767impl<A, B> DeRon for (A, B) where A: DeRon,
768B: DeRon {
769    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B), DeRonErr> {
770        s.paren_open(i) ?;
771        let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?);
772        s.paren_close(i) ?;
773        Ok(r)
774    }
775}
776
777impl<A, B, C> SerRon for (A, B, C) where A: SerRon,
778B: SerRon,
779C: SerRon {
780    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
781        s.out.push('(');
782        self.0.ser_ron(d, s);
783        s.out.push_str(", ");
784        self.1.ser_ron(d, s);
785        s.out.push_str(", ");
786        self.2.ser_ron(d, s);
787        s.out.push(')');
788    }
789}
790
791impl<A, B, C> DeRon for (A, B, C) where A: DeRon,
792B: DeRon,
793C: DeRon {
794    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B, C), DeRonErr> {
795        s.paren_open(i) ?;
796        let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?);
797        s.paren_close(i) ?;
798        Ok(r)
799    }
800}
801
802impl<A, B, C, D> SerRon for (A, B, C, D) where A: SerRon,
803B: SerRon,
804C: SerRon,
805D: SerRon {
806    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
807        s.out.push('(');
808        self.0.ser_ron(d, s);
809        s.out.push_str(", ");
810        self.1.ser_ron(d, s);
811        s.out.push_str(", ");
812        self.2.ser_ron(d, s);
813        s.out.push_str(", ");
814        self.3.ser_ron(d, s);
815        s.out.push(')');
816    }
817}
818
819impl<A, B, C, D> DeRon for (A, B, C, D) where A: DeRon,
820B: DeRon,
821C: DeRon,
822D: DeRon {
823    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B, C, D), DeRonErr> {
824        s.paren_open(i) ?;
825        let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?);
826        s.paren_close(i) ?;
827        Ok(r)
828    }
829}
830
831impl<K, V> SerRon for HashMap<K, V> where K: SerRon,
832V: SerRon {
833    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
834        s.out.push_str("{\n");
835        for (k, v) in self {
836            s.indent(d + 1);
837            k.ser_ron(d + 1, s);
838            s.out.push(':');
839            v.ser_ron(d + 1, s);
840            s.conl();
841        }
842        s.indent(d);
843        s.out.push('}');
844    }
845}
846
847impl<K, V> DeRon for HashMap<K, V> where K: DeRon + Eq + Hash,
848V: DeRon {
849    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Self,
850    DeRonErr> {
851        let mut h = HashMap::new();
852        s.curly_open(i) ?;
853        while s.tok != DeRonTok::CurlyClose {
854            let k = DeRon::de_ron(s, i) ?;
855            s.colon(i) ?;
856            let v = DeRon::de_ron(s, i) ?;
857            s.eat_comma_curly(i) ?;
858            h.insert(k, v);
859        }
860        s.curly_close(i) ?;
861        Ok(h)
862    }
863}
864
865impl<T> SerRon for Box<T> where T: SerRon {
866    fn ser_ron(&self, d: usize, s: &mut SerRonState) {
867        (**self).ser_ron(d, s)
868    }
869}
870
871impl<T> DeRon for Box<T> where T: DeRon {
872    fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<Box<T>, DeRonErr> {
873        Ok(Box::new(DeRon::de_ron(s, i) ?))
874    }
875}
makepad_micro_serde/serde_ron.rs

makepad_micro_serde/
serde_ron.rs
