makepad_micro_serde/
serde_ron.rs

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

makepad_micro_serde/
serde_ron.rs
