makepad_micro_serde/
serde_json.rs

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

makepad_micro_serde/
serde_json.rs
