makepad_micro_serde/
serde_json.rs

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

makepad_micro_serde/
serde_json.rs
