xCommonLib/serial/
json_to_proto.rs

1use super::api_descriptor::{get_wire_type, is_map, make_tag};
2use crate::base::status::Status;
3use crate::serial::api_descriptor::{is_array, ServiceApiDescriptor};
4use protobuf::descriptor::field_descriptor_proto::Type;
5use protobuf::descriptor::FieldDescriptorProto;
6use protobuf::CodedOutputStream;
7use serde_json::Value;
8
9// bool
10fn compute_one_bool_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
11    if !json_value.is_boolean() {
12        return Err(Status::error(format!(
13            "{} 类型错误！",
14            field.name.as_ref().unwrap()
15        )));
16    }
17    let value = json_value.as_bool().unwrap();
18    if value == false {
19        return Ok(0);
20    }
21    // TYPE_BOOL == 8
22    let tag = (field.number() << 3) | 8;
23    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
24    return Ok(tag_size + 1);
25}
26
27fn compute_bool_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
28    let mut size = 0;
29    if is_array(field) {
30        if !json_value.is_array() {
31            return Err(Status::error(format!(
32                "{} 类型错误, 应为数组！",
33                field.name.as_ref().unwrap()
34            )));
35        }
36        for ele in json_value.as_array().unwrap() {
37            size += compute_one_bool_size(field, ele)?;
38        }
39        Ok(size)
40    } else {
41        compute_one_bool_size(field, json_value)
42    }
43}
44
45fn write_one_bool(
46    field: &FieldDescriptorProto,
47    json_value: &Value,
48    output_stream: &mut CodedOutputStream,
49) -> Result<(), Status> {
50    let number = field.number.unwrap() as u32;
51    let value = json_value.as_bool().unwrap();
52    if value == false {
53        return Ok(());
54    }
55    let result = output_stream.write_bool(number, value);
56    if result.is_err() {
57        return Err(Status::error(format!(
58            "{} 序列化失败！",
59            field.name.as_ref().unwrap()
60        )));
61    }
62    Ok(())
63}
64
65//
66fn write_bool(
67    field: &FieldDescriptorProto,
68    json_value: &Value,
69    output_stream: &mut CodedOutputStream,
70) -> Result<(), Status> {
71    if is_array(field) {
72        for ele in json_value.as_array().unwrap() {
73            write_one_bool(field, ele, output_stream)?;
74        }
75        Ok(())
76    } else {
77        write_one_bool(field, json_value, output_stream)
78    }
79}
80
81// float
82
83fn compute_one_float_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
84    if !json_value.is_f64() {
85        return Err(Status::error(format!(
86            "{} 类型错误！",
87            field.name.as_ref().unwrap()
88        )));
89    }
90    let value = json_value.as_f64().unwrap();
91    if value == 0.0 {
92        return Ok(0);
93    }
94    let tag = (field.number() << 3) | 2;
95    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
96
97    return Ok(tag_size + 4);
98}
99
100fn compute_float_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
101    let mut size = 0;
102    if is_array(field) {
103        if !json_value.is_array() {
104            return Err(Status::error(format!(
105                "{} 类型错误, 应为数组！",
106                field.name.as_ref().unwrap()
107            )));
108        }
109        for ele in json_value.as_array().unwrap() {
110            size += compute_one_float_size(field, ele)?;
111        }
112        Ok(size)
113    } else {
114        compute_one_float_size(field, json_value)
115    }
116}
117
118fn write_one_float(
119    field: &FieldDescriptorProto,
120    json_value: &Value,
121    output_stream: &mut CodedOutputStream,
122) -> Result<(), Status> {
123    let number = field.number.unwrap() as u32;
124    let value = json_value.as_f64().unwrap();
125    if value == 0.0 {
126        return Ok(());
127    }
128    let result = output_stream.write_float(number, value as f32);
129    if result.is_err() {
130        return Err(Status::error(format!(
131            "{} 序列化失败！",
132            field.name.as_ref().unwrap()
133        )));
134    }
135    Ok(())
136}
137
138//
139fn write_float(
140    field: &FieldDescriptorProto,
141    json_value: &Value,
142    output_stream: &mut CodedOutputStream,
143) -> Result<(), Status> {
144    if is_array(field) {
145        for ele in json_value.as_array().unwrap() {
146            write_one_float(field, ele, output_stream)?;
147        }
148        Ok(())
149    } else {
150        write_one_float(field, json_value, output_stream)
151    }
152}
153
154fn compute_one_double_size(
155    field: &FieldDescriptorProto,
156    json_value: &Value,
157) -> Result<u64, Status> {
158    if !json_value.is_f64() {
159        return Err(Status::error(format!(
160            "{} 类型错误！",
161            field.name.as_ref().unwrap()
162        )));
163    }
164    let value = json_value.as_f64().unwrap();
165    if value == 0.0 {
166        return Ok(0);
167    }
168    // Type::TYPE_DOUBLE = 1
169    let tag = (field.number() << 3) | 1;
170    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
171
172    return Ok(tag_size + 8);
173}
174
175fn compute_double_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
176    let mut size = 0;
177    if is_array(field) {
178        if !json_value.is_array() {
179            return Err(Status::error(format!(
180                "{} 类型错误, 应为数组！",
181                field.name.as_ref().unwrap()
182            )));
183        }
184        for ele in json_value.as_array().unwrap() {
185            size += compute_one_double_size(field, ele)?;
186        }
187        Ok(size)
188    } else {
189        compute_one_double_size(field, json_value)
190    }
191}
192
193// double
194fn write_one_double(
195    field: &FieldDescriptorProto,
196    json_value: &Value,
197    output_stream: &mut CodedOutputStream,
198) -> Result<(), Status> {
199    let number = field.number.unwrap() as u32;
200    let value = json_value.as_f64().unwrap();
201    if value == 0.0 {
202        return Ok(());
203    }
204    let result = output_stream.write_double(number, value);
205    if result.is_err() {
206        return Err(Status::error(format!(
207            "{} 序列化失败！",
208            field.name.as_ref().unwrap()
209        )));
210    }
211    Ok(())
212}
213
214//
215fn write_double(
216    field: &FieldDescriptorProto,
217    json_value: &Value,
218    output_stream: &mut CodedOutputStream,
219) -> Result<(), Status> {
220    if is_array(field) {
221        for ele in json_value.as_array().unwrap() {
222            write_one_double(field, ele, output_stream)?;
223        }
224        Ok(())
225    } else {
226        write_one_double(field, json_value, output_stream)
227    }
228}
229
230fn compute_one_sint64_size(
231    field: &FieldDescriptorProto,
232    json_value: &Value,
233) -> Result<u64, Status> {
234    let number = field.number.unwrap() as u32;
235    if !json_value.is_i64() {
236        return Err(Status::error(format!(
237            "{} 类型错误！",
238            field.name.as_ref().unwrap()
239        )));
240    }
241    let value = json_value.as_i64().unwrap();
242    if value == 0 {
243        return Ok(0);
244    }
245    return Ok(protobuf::rt::sint64_size(number, value));
246}
247
248fn compute_sint64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
249    let mut size = 0;
250
251    if is_array(field) {
252        if !json_value.is_array() {
253            return Err(Status::error(format!(
254                "{} 类型错误, 应为数组！",
255                field.name.as_ref().unwrap()
256            )));
257        }
258        for ele in json_value.as_array().unwrap() {
259            size += compute_one_sint64_size(field, ele)?;
260        }
261        Ok(size)
262    } else {
263        compute_one_sint64_size(field, json_value)
264    }
265}
266
267// sint64
268fn write_one_sint64(
269    field: &FieldDescriptorProto,
270    json_value: &Value,
271    output_stream: &mut CodedOutputStream,
272) -> Result<(), Status> {
273    let number = field.number.unwrap() as u32;
274    let value = json_value.as_i64().unwrap();
275    if value == 0 {
276        return Ok(());
277    }
278    let result = output_stream.write_sint64(number, value);
279    if result.is_err() {
280        return Err(Status::error(format!(
281            "{} 序列化失败！",
282            field.name.as_ref().unwrap()
283        )));
284    }
285    Ok(())
286}
287
288//
289fn write_sint64(
290    field: &FieldDescriptorProto,
291    json_value: &Value,
292    output_stream: &mut CodedOutputStream,
293) -> Result<(), Status> {
294    if is_array(field) {
295        for ele in json_value.as_array().unwrap() {
296            write_one_sint64(field, ele, output_stream)?;
297        }
298        Ok(())
299    } else {
300        write_one_sint64(field, json_value, output_stream)
301    }
302}
303
304//
305fn compute_one_sint32_size(
306    field: &FieldDescriptorProto,
307    json_value: &Value,
308) -> Result<u64, Status> {
309    let number = field.number.unwrap() as u32;
310    if !json_value.is_i64() {
311        return Err(Status::error(format!(
312            "{} 类型错误！",
313            field.name.as_ref().unwrap()
314        )));
315    }
316    let value = json_value.as_i64().unwrap();
317    if value == 0 {
318        return Ok(0);
319    }
320    return Ok(protobuf::rt::sint32_size(number, value as i32));
321}
322
323fn compute_sint32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
324    let mut size = 0;
325    if is_array(field) {
326        if !json_value.is_array() {
327            return Err(Status::error(format!(
328                "{} 类型错误, 应为数组！",
329                field.name.as_ref().unwrap()
330            )));
331        }
332        for ele in json_value.as_array().unwrap() {
333            size += compute_one_sint32_size(field, ele)?;
334        }
335        Ok(size)
336    } else {
337        compute_one_sint32_size(field, json_value)
338    }
339}
340
341// sint32
342fn write_one_sint32(
343    field: &FieldDescriptorProto,
344    json_value: &Value,
345    output_stream: &mut CodedOutputStream,
346) -> Result<(), Status> {
347    let number = field.number.unwrap() as u32;
348    let value = json_value.as_i64().unwrap();
349    if value == 0 {
350        return Ok(());
351    }
352    let result = output_stream.write_sint32(number, value as i32);
353    if result.is_err() {
354        return Err(Status::error(format!(
355            "{} 序列化失败！",
356            field.name.as_ref().unwrap()
357        )));
358    }
359    Ok(())
360}
361
362//
363fn write_sint32(
364    field: &FieldDescriptorProto,
365    json_value: &Value,
366    output_stream: &mut CodedOutputStream,
367) -> Result<(), Status> {
368    if is_array(field) {
369        for ele in json_value.as_array().unwrap() {
370            write_one_sint32(field, ele, output_stream)?;
371        }
372        Ok(())
373    } else {
374        write_one_sint32(field, json_value, output_stream)
375    }
376}
377
378//
379fn compute_one_sfixed64_size(
380    field: &FieldDescriptorProto,
381    json_value: &Value,
382) -> Result<u64, Status> {
383    if !json_value.is_i64() {
384        return Err(Status::error(format!(
385            "{} 类型错误！",
386            field.name.as_ref().unwrap()
387        )));
388    }
389
390    let value = json_value.as_i64().unwrap();
391    if value == 0 {
392        return Ok(0);
393    }
394    
395    // TYPE_SFIXED64 = 15
396    let tag = (field.number() << 3) | 16;
397    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
398	
399    return Ok(tag_size + 8);
400}
401
402fn compute_sfixed64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
403    let mut size = 0;
404    if is_array(field) {
405        if !json_value.is_array() {
406            return Err(Status::error(format!(
407                "{} 类型错误, 应为数组！",
408                field.name.as_ref().unwrap()
409            )));
410        }
411        for ele in json_value.as_array().unwrap() {
412            size += compute_one_sfixed64_size(field, ele)?;
413        }
414        Ok(size)
415    } else {
416        compute_one_sfixed64_size(field, json_value)
417    }
418}
419
420// sfixed64
421fn write_one_sfixed64(
422    field: &FieldDescriptorProto,
423    json_value: &Value,
424    output_stream: &mut CodedOutputStream,
425) -> Result<(), Status> {
426    let number = field.number.unwrap() as u32;
427    let value = json_value.as_i64().unwrap();
428    if value == 0 {
429        return Ok(());
430    }
431    let result = output_stream.write_sfixed64(number, value);
432    if result.is_err() {
433        return Err(Status::error(format!(
434            "{} 序列化失败！",
435            field.name.as_ref().unwrap()
436        )));
437    }
438    Ok(())
439}
440
441//
442fn write_sfixed64(
443    field: &FieldDescriptorProto,
444    json_value: &Value,
445    output_stream: &mut CodedOutputStream,
446) -> Result<(), Status> {
447    if is_array(field) {
448        for ele in json_value.as_array().unwrap() {
449            write_one_sfixed64(field, ele, output_stream)?;
450        }
451        Ok(())
452    } else {
453        write_one_sfixed64(field, json_value, output_stream)
454    }
455}
456
457//
458fn compute_one_sfixed32_size(
459    field: &FieldDescriptorProto,
460    json_value: &Value,
461) -> Result<u64, Status> {
462    if !json_value.is_i64() {
463        return Err(Status::error(format!(
464            "{} 类型错误！",
465            field.name.as_ref().unwrap()
466        )));
467    }
468    let value = json_value.as_i64().unwrap();
469    if value == 0 {
470        return Ok(0);
471    }
472
473    return Ok(::protobuf::rt::sint32_size(
474        field.number() as u32,
475        value as i32,
476    ));
477}
478
479fn compute_sfixed32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
480    let mut size = 0;
481    if is_array(field) {
482        if !json_value.is_array() {
483            return Err(Status::error(format!(
484                "{} 类型错误, 应为数组！",
485                field.name.as_ref().unwrap()
486            )));
487        }
488        for ele in json_value.as_array().unwrap() {
489            size += compute_one_sfixed32_size(field, ele)?;
490        }
491        Ok(size)
492    } else {
493        compute_one_sfixed32_size(field, json_value)
494    }
495}
496
497// sfixed32
498fn write_one_sfixed32(
499    field: &FieldDescriptorProto,
500    json_value: &Value,
501    output_stream: &mut CodedOutputStream,
502) -> Result<(), Status> {
503    let number = field.number.unwrap() as u32;
504    let value = json_value.as_i64().unwrap();
505    if value == 0 {
506        return Ok(());
507    }
508    let result = output_stream.write_sfixed32(number, value as i32);
509    if result.is_err() {
510        return Err(Status::error(format!(
511            "{} 序列化失败！",
512            field.name.as_ref().unwrap()
513        )));
514    }
515    Ok(())
516}
517
518//
519fn write_sfixed32(
520    field: &FieldDescriptorProto,
521    json_value: &Value,
522    output_stream: &mut CodedOutputStream,
523) -> Result<(), Status> {
524    if is_array(field) {
525        for ele in json_value.as_array().unwrap() {
526            write_one_sfixed32(field, ele, output_stream)?;
527        }
528        Ok(())
529    } else {
530        write_one_sfixed32(field, json_value, output_stream)
531    }
532}
533
534//
535fn compute_one_enum_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
536    let number = field.number.unwrap() as u32;
537    if !json_value.is_i64() {
538        return Err(Status::error(format!(
539            "{} 类型错误！",
540            field.name.as_ref().unwrap()
541        )));
542    }
543    let value = json_value.as_i64().unwrap();
544    if value == 0 {
545        return Ok(0);
546    }
547    return Ok(protobuf::rt::int32_size(number, value as i32));
548}
549
550fn compute_enum_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
551    let mut size = 0;
552    if is_array(field) {
553        if !json_value.is_array() {
554            return Err(Status::error(format!(
555                "{} 类型错误, 应为数组！",
556                field.name.as_ref().unwrap()
557            )));
558        }
559        for ele in json_value.as_array().unwrap() {
560            size += compute_one_enum_size(field, ele)?;
561        }
562        Ok(size)
563    } else {
564        compute_one_enum_size(field, json_value)
565    }
566}
567
568// enum
569fn write_one_enum(
570    field: &FieldDescriptorProto,
571    json_value: &Value,
572    output_stream: &mut CodedOutputStream,
573) -> Result<(), Status> {
574    let number = field.number.unwrap() as u32;
575    let value = json_value.as_i64().unwrap();
576    if value == 0 {
577        return Ok(());
578    }
579    let result = output_stream.write_enum(number, value as i32);
580    if result.is_err() {
581        return Err(Status::error(format!(
582            "{} 序列化失败！",
583            field.name.as_ref().unwrap()
584        )));
585    }
586    Ok(())
587}
588
589//
590fn write_enum(
591    field: &FieldDescriptorProto,
592    json_value: &Value,
593    output_stream: &mut CodedOutputStream,
594) -> Result<(), Status> {
595    if is_array(field) {
596        for ele in json_value.as_array().unwrap() {
597            write_one_enum(field, ele, output_stream)?;
598        }
599        Ok(())
600    } else {
601        write_one_enum(field, json_value, output_stream)
602    }
603}
604
605fn compute_one_uint32_size(
606    field: &FieldDescriptorProto,
607    json_value: &Value,
608) -> Result<u64, Status> {
609    if !json_value.is_u64() {
610        return Err(Status::error(format!(
611            "{} 类型错误！",
612            field.name.as_ref().unwrap()
613        )));
614    }
615    let value = json_value.as_u64().unwrap();
616    if value == 0 {
617        return Ok(0);
618    }
619    let number = field.number.unwrap() as u32;
620    return Ok(protobuf::rt::uint32_size(number, value as u32));
621}
622
623fn compute_uint32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
624    let mut size = 0;
625    if is_array(field) {
626        if !json_value.is_array() {
627            return Err(Status::error(format!(
628                "{} 类型错误, 应为数组！",
629                field.name.as_ref().unwrap()
630            )));
631        }
632        for ele in json_value.as_array().unwrap() {
633            size += compute_one_uint32_size(field, ele)?;
634        }
635        Ok(size)
636    } else {
637        compute_one_uint32_size(field, json_value)
638    }
639}
640
641// uint32
642fn write_one_uint32(
643    field: &FieldDescriptorProto,
644    json_value: &Value,
645    output_stream: &mut CodedOutputStream,
646) -> Result<(), Status> {
647    let value = json_value.as_u64().unwrap();
648    if value == 0 {
649        return Ok(());
650    }
651    let number = field.number.unwrap() as u32;
652    let result = output_stream.write_uint32(number, value as u32);
653    if result.is_err() {
654        return Err(Status::error(format!(
655            "{} 序列化失败！",
656            field.name.as_ref().unwrap()
657        )));
658    }
659    Ok(())
660}
661
662//
663fn write_uint32(
664    field: &FieldDescriptorProto,
665    json_value: &Value,
666    output_stream: &mut CodedOutputStream,
667) -> Result<(), Status> {
668    if is_array(field) {
669        for ele in json_value.as_array().unwrap() {
670            write_one_uint32(field, ele, output_stream)?;
671        }
672        Ok(())
673    } else {
674        write_one_uint32(field, json_value, output_stream)
675    }
676}
677//
678
679fn compute_one_fixed32_size(
680    field: &FieldDescriptorProto,
681    json_value: &Value,
682) -> Result<u64, Status> {
683    if !json_value.is_u64() {
684        return Err(Status::error(format!(
685            "{} 类型错误！",
686            field.name.as_ref().unwrap()
687        )));
688    }
689    let value = json_value.as_u64().unwrap();
690    if value == 0 {
691        return Ok(0);
692    }
693
694    // TYPE_FIXED32 = 7
695    let tag = (field.number() << 3) | 7;
696    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
697    return Ok(tag_size + 4);
698}
699
700fn compute_fixed32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
701    let mut size = 0;
702    if is_array(field) {
703        if !json_value.is_array() {
704            return Err(Status::error(format!(
705                "{} 类型错误, 应为数组！",
706                field.name.as_ref().unwrap()
707            )));
708        }
709        for ele in json_value.as_array().unwrap() {
710            size += compute_one_fixed32_size(field, ele)?;
711        }
712        Ok(size)
713    } else {
714        compute_one_fixed32_size(field, json_value)
715    }
716}
717
718//
719// fixed32
720fn write_one_fixed32(
721    field: &FieldDescriptorProto,
722    json_value: &Value,
723    output_stream: &mut CodedOutputStream,
724) -> Result<(), Status> {
725    let number = field.number.unwrap() as u32;
726    let value = json_value.as_u64().unwrap();
727    if value == 0 {
728        return Ok(());
729    }
730    let result = output_stream.write_fixed32(number, value as u32);
731    if result.is_err() {
732        return Err(Status::error(format!(
733            "{} 序列化失败！",
734            field.name.as_ref().unwrap()
735        )));
736    }
737    Ok(())
738}
739//
740
741//
742fn write_fixed32(
743    field: &FieldDescriptorProto,
744    json_value: &Value,
745    output_stream: &mut CodedOutputStream,
746) -> Result<(), Status> {
747    if is_array(field) {
748        for ele in json_value.as_array().unwrap() {
749            write_one_fixed32(field, ele, output_stream)?;
750        }
751        Ok(())
752    } else {
753        write_one_fixed32(field, json_value, output_stream)
754    }
755}
756
757// fixed64
758fn write_one_fixed64(
759    field: &FieldDescriptorProto,
760    json_value: &Value,
761    output_stream: &mut CodedOutputStream,
762) -> Result<(), Status> {
763    let number = field.number.unwrap() as u32;
764
765    let value = json_value.as_u64().unwrap();
766    if value == 0 {
767        return Ok(());
768    }
769    let result = output_stream.write_fixed64(number, value);
770    if result.is_err() {
771        return Err(Status::error(format!(
772            "{} 序列化失败！",
773            field.name.as_ref().unwrap()
774        )));
775    }
776    Ok(())
777}
778
779fn compute_one_fixed64_size(
780    field: &FieldDescriptorProto,
781    json_value: &Value,
782) -> Result<u64, Status> {
783    if !json_value.is_u64() {
784        return Err(Status::error(format!(
785            "{} 类型错误！",
786            field.name.as_ref().unwrap()
787        )));
788    }
789    let value = json_value.as_u64().unwrap();
790    if value == 0 {
791        return Ok(0);
792    }
793    // TYPE_FIXED64 = 15
794    let tag = (field.number() << 3) | 6;
795    let tag_size = ::protobuf::rt::compute_raw_varint64_size(tag as u64);
796    return Ok(tag_size + 8);
797}
798
799fn compute_fixed64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
800    let mut size = 0;
801    if is_array(field) {
802        if !json_value.is_array() {
803            return Err(Status::error(format!(
804                "{} 类型错误, 应为数组！",
805                field.name.as_ref().unwrap()
806            )));
807        }
808        for ele in json_value.as_array().unwrap() {
809            size += compute_one_fixed64_size(field, ele)?;
810        }
811        Ok(size)
812    } else {
813        compute_one_fixed64_size(field, json_value)
814    }
815}
816
817//
818fn write_fixed64(
819    field: &FieldDescriptorProto,
820    json_value: &Value,
821    output_stream: &mut CodedOutputStream,
822) -> Result<(), Status> {
823    if is_array(field) {
824        for ele in json_value.as_array().unwrap() {
825            write_one_fixed64(field, ele, output_stream)?;
826        }
827        Ok(())
828    } else {
829        write_one_fixed64(field, json_value, output_stream)
830    }
831}
832
833//
834fn compute_one_int32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
835    let number = field.number.unwrap() as u32;
836    if !json_value.is_i64() {
837        return Err(Status::error(format!(
838            "{} 类型错误！",
839            field.name.as_ref().unwrap()
840        )));
841    }
842    let value = json_value.as_i64().unwrap();
843    if value == 0 {
844        return Ok(0);
845    }
846    return Ok(protobuf::rt::int32_size(number, value as i32));
847}
848
849fn compute_int32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
850    let mut size = 0;
851    if is_array(field) {
852        if !json_value.is_array() {
853            return Err(Status::error(format!(
854                "{} 类型错误, 应为数组！",
855                field.name.as_ref().unwrap()
856            )));
857        }
858        for ele in json_value.as_array().unwrap() {
859            size += compute_one_int32_size(field, ele)?;
860        }
861        Ok(size)
862    } else {
863        compute_one_int32_size(field, json_value)
864    }
865}
866
867// i32
868fn write_one_int32(
869    field: &FieldDescriptorProto,
870    json_value: &Value,
871    output_stream: &mut CodedOutputStream,
872) -> Result<(), Status> {
873    let number = field.number.unwrap() as u32;
874    let value = json_value.as_i64().unwrap();
875    if value == 0 {
876        return Ok(());
877    }
878    let result = output_stream.write_int32(number, value as i32);
879    if result.is_err() {
880        return Err(Status::error(format!(
881            "{} 序列化失败！",
882            field.name.as_ref().unwrap()
883        )));
884    }
885    Ok(())
886}
887
888//
889fn write_int32(
890    field: &FieldDescriptorProto,
891    json_value: &Value,
892    output_stream: &mut CodedOutputStream,
893) -> Result<(), Status> {
894    if is_array(field) {
895        for ele in json_value.as_array().unwrap() {
896            write_one_int32(field, ele, output_stream)?;
897        }
898        Ok(())
899    } else {
900        write_one_int32(field, json_value, output_stream)
901    }
902}
903
904fn compute_one_uint64_size(
905    field: &FieldDescriptorProto,
906    json_value: &Value,
907) -> Result<u64, Status> {
908    let number = field.number.unwrap() as u32;
909    if !json_value.is_u64() {
910        return Err(Status::error(format!(
911            "{} 类型错误！",
912            field.name.as_ref().unwrap()
913        )));
914    }
915    let value = json_value.as_u64().unwrap();
916    if value == 0 {
917        return Ok(0);
918    }
919    return Ok(protobuf::rt::uint64_size(number, value));
920}
921
922fn compute_uint64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
923    let mut size = 0;
924    if is_array(field) {
925        if !json_value.is_array() {
926            return Err(Status::error(format!(
927                "{} 类型错误, 应为数组！",
928                field.name.as_ref().unwrap()
929            )));
930        }
931        for ele in json_value.as_array().unwrap() {
932            size += compute_one_uint64_size(field, ele)?;
933        }
934        Ok(size)
935    } else {
936        compute_one_uint64_size(field, json_value)
937    }
938}
939
940// u64
941fn write_one_uint64(
942    field: &FieldDescriptorProto,
943    json_value: &Value,
944    output_stream: &mut CodedOutputStream,
945) -> Result<(), Status> {
946    let number = field.number.unwrap() as u32;
947    let value = json_value.as_u64().unwrap();
948    if value == 0 {
949        return Ok(());
950    }
951    let result = output_stream.write_uint64(number, value);
952    if result.is_err() {
953        return Err(Status::error(format!(
954            "{} 序列化失败！",
955            field.name.as_ref().unwrap()
956        )));
957    }
958    Ok(())
959}
960
961//
962fn write_uint64(
963    field: &FieldDescriptorProto,
964    json_value: &Value,
965    output_stream: &mut CodedOutputStream,
966) -> Result<(), Status> {
967    if is_array(field) {
968        for ele in json_value.as_array().unwrap() {
969            write_one_uint64(field, ele, output_stream)?;
970        }
971        Ok(())
972    } else {
973        write_one_uint64(field, json_value, output_stream)
974    }
975}
976//
977
978fn compute_one_int64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
979    let number = field.number.unwrap() as u32;
980    if !json_value.is_i64() {
981        return Err(Status::error(format!(
982            "{} 类型错误！",
983            field.name.as_ref().unwrap()
984        )));
985    }
986    let value = json_value.as_i64().unwrap();
987    if value == 0 {
988        return Ok(0);
989    }
990    return Ok(protobuf::rt::int64_size(number, value));
991}
992
993fn compute_int64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
994    let mut size = 0;
995
996    if is_array(field) {
997        if !json_value.is_array() {
998            return Err(Status::error(format!(
999                "{} 类型错误, 应为数组！",
1000                field.name.as_ref().unwrap()
1001            )));
1002        }
1003        for ele in json_value.as_array().unwrap() {
1004            size += compute_one_int64_size(field, ele)?;
1005        }
1006        Ok(size)
1007    } else {
1008        compute_one_int64_size(field, json_value)
1009    }
1010}
1011
1012//
1013fn write_one_int64(
1014    field: &FieldDescriptorProto,
1015    json_value: &Value,
1016    output_stream: &mut CodedOutputStream,
1017) -> Result<(), Status> {
1018    let number = field.number.unwrap() as u32;
1019    let value = json_value.as_i64().unwrap();
1020    if value == 0 {
1021        return Ok(());
1022    }
1023    let result = output_stream.write_int64(number, value);
1024    if result.is_err() {
1025        return Err(Status::error(format!(
1026            "{} 序列化失败！",
1027            field.name.as_ref().unwrap()
1028        )));
1029    }
1030    Ok(())
1031}
1032
1033//
1034fn write_int64(
1035    field: &FieldDescriptorProto,
1036    json_value: &Value,
1037    output_stream: &mut CodedOutputStream,
1038) -> Result<(), Status> {
1039    if is_array(field) {
1040        for ele in json_value.as_array().unwrap() {
1041            write_one_int64(field, ele, output_stream)?;
1042        }
1043        Ok(())
1044    } else {
1045        write_one_int64(field, json_value, output_stream)
1046    }
1047}
1048
1049// 写入字符串
1050
1051fn compute_one_string_size(
1052    field: &FieldDescriptorProto,
1053    json_value: &Value,
1054) -> Result<u64, Status> {
1055    let number = field.number.unwrap() as u32;
1056    if !json_value.is_string() {
1057        return Err(Status::error(format!(
1058            "{} 类型错误！",
1059            field.name.as_ref().unwrap()
1060        )));
1061    }
1062    let value = json_value.as_str().unwrap();
1063    if value.is_empty() {
1064        return Ok(0);
1065    }
1066    Ok(protobuf::rt::string_size(number, value))
1067}
1068
1069//
1070fn compute_string_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
1071    let mut size = 0;
1072    if is_array(field) {
1073        if !json_value.is_array() {
1074            return Err(Status::error(format!(
1075                "{} 类型错误, 应为数组！",
1076                field.name.as_ref().unwrap()
1077            )));
1078        }
1079        for ele in json_value.as_array().unwrap() {
1080            size += compute_one_string_size(field, ele)?;
1081        }
1082        Ok(size)
1083    } else {
1084        compute_one_string_size(field, json_value)
1085    }
1086}
1087
1088fn write_one_string(
1089    field: &FieldDescriptorProto,
1090    json_value: &Value,
1091    output_stream: &mut CodedOutputStream,
1092) -> Result<(), Status> {
1093    let number = field.number.unwrap() as u32;
1094    let value = json_value.as_str().unwrap();
1095    if value.is_empty() {
1096        return Ok(());
1097    }
1098    let result = output_stream.write_string(number, value);
1099    if result.is_err() {
1100        return Err(Status::error(format!(
1101            "{} 序列化失败！",
1102            field.name.as_ref().unwrap()
1103        )));
1104    }
1105    Ok(())
1106}
1107
1108//
1109fn write_string(
1110    field: &FieldDescriptorProto,
1111    json_value: &Value,
1112    output_stream: &mut CodedOutputStream,
1113) -> Result<(), Status> {
1114    if is_array(field) {
1115        for ele in json_value.as_array().unwrap() {
1116            write_one_string(field, ele, output_stream)?;
1117        }
1118        Ok(())
1119    } else {
1120        write_one_string(field, json_value, output_stream)
1121    }
1122}
1123
1124fn compute_object_size(
1125    field: &FieldDescriptorProto,
1126    json_value: &Value,
1127    service_api_descriptor: &ServiceApiDescriptor,
1128) -> Result<u64, Status> {
1129    if field.type_name.is_none() {
1130        return Err(Status::error(format!(
1131            "{} 类型错误, 应为数组！",
1132            field.name.as_ref().unwrap()
1133        )));
1134    }
1135
1136    let type_name = field.type_name.as_ref().unwrap();
1137    let mut size = 0;
1138    if is_array(field) {
1139        if !json_value.is_array() {
1140            return Err(Status::error(format!(
1141                "{} 类型错误, 应为数组！",
1142                field.name.as_ref().unwrap()
1143            )));
1144        }
1145        for ele in json_value.as_array().unwrap() {
1146            let len = compute_size(ele, type_name, service_api_descriptor)?;
1147            size += 1 + protobuf::rt::compute_raw_varint64_size(len) + len;
1148        }
1149    } else {
1150        let len = compute_size(json_value, type_name, service_api_descriptor)?;
1151
1152        size = 1 + protobuf::rt::compute_raw_varint64_size(len) + len;
1153    }
1154    Ok(size)
1155}
1156
1157fn write_object(
1158    field: &FieldDescriptorProto,
1159    json_value: &Value,
1160    service_api_descriptor: &ServiceApiDescriptor,
1161    output_stream: &mut CodedOutputStream,
1162) -> Result<(), Status> {
1163    let type_name = field.type_name.as_ref().unwrap();
1164
1165    if is_array(field) {
1166        let number = field.number.unwrap() as u32;
1167        for ele in json_value.as_array().unwrap() {
1168            output_stream
1169                .write_tag(number, protobuf::rt::WireType::LengthDelimited)
1170                .unwrap();
1171            let len = compute_size(ele, type_name, service_api_descriptor)?;
1172            output_stream.write_raw_varint32(len as u32).unwrap();
1173
1174            json_to_proto_with_buffer(ele, type_name, service_api_descriptor, output_stream)?;
1175        }
1176        Ok(())
1177    } else {
1178        let number = field.number.unwrap() as u32;
1179        output_stream
1180            .write_tag(number, protobuf::rt::WireType::LengthDelimited)
1181            .unwrap();
1182        let len = compute_size(json_value, type_name, service_api_descriptor)?;
1183        output_stream.write_raw_varint32(len as u32).unwrap();
1184
1185        json_to_proto_with_buffer(json_value, type_name, service_api_descriptor, output_stream)
1186    }
1187}
1188
1189fn compute_json_key_size(field_type: Type, key: &str) -> Result<u64, Status> {
1190    match field_type {
1191        Type::TYPE_DOUBLE => Ok(2 + 8),
1192        Type::TYPE_FLOAT => Ok(2 + 4),
1193        Type::TYPE_INT64 => {
1194            let value: Result<i64, _> = key.parse();
1195            Ok(::protobuf::rt::int64_size(1, value.unwrap()))
1196        }
1197        Type::TYPE_UINT64 => {
1198            let value: Result<u64, _> = key.parse();
1199            Ok(::protobuf::rt::uint64_size(1, value.unwrap()))
1200        }
1201        Type::TYPE_INT32 => {
1202            let value: Result<i32, _> = key.parse();
1203            Ok(::protobuf::rt::int32_size(1, value.unwrap()))
1204        }
1205        Type::TYPE_FIXED64 => Ok(1 + 8),
1206        Type::TYPE_FIXED32 => Ok(1 + 4),
1207        Type::TYPE_BOOL => Ok(2 + 1),
1208        Type::TYPE_STRING => Ok(::protobuf::rt::string_size(1, key)),
1209        Type::TYPE_UINT32 => {
1210            let value: Result<u32, _> = key.parse();
1211            Ok(::protobuf::rt::uint32_size(1, value.unwrap()))
1212        }
1213        Type::TYPE_SFIXED32 => Ok(2 + 8),
1214        Type::TYPE_SFIXED64 => Ok(2 + 4),
1215        Type::TYPE_SINT32 => {
1216            let value: Result<i32, _> = key.parse();
1217            Ok(::protobuf::rt::sint32_size(1, value.unwrap()))
1218        }
1219        Type::TYPE_SINT64 => {
1220            let value: Result<i64, _> = key.parse();
1221            Ok(::protobuf::rt::sint64_size(1, value.unwrap()))
1222        }
1223        _ => {
1224            return Err(Status::error(format!("无消息 描述信息！")));
1225        }
1226    }
1227}
1228
1229fn compute_size_inner(
1230    field_type: Type,
1231    field: &FieldDescriptorProto,
1232    service_api_descriptor: &ServiceApiDescriptor,
1233    json_value: &Value,
1234) -> Result<u64, Status> {
1235    // field.nu
1236    match field_type {
1237        // i64
1238        Type::TYPE_INT64 => compute_int64_size(field, json_value),
1239        // ui64
1240        Type::TYPE_UINT64 => compute_uint64_size(field, json_value),
1241        // i32
1242        Type::TYPE_INT32 => compute_int32_size(field, json_value),
1243        // fixed64
1244        Type::TYPE_FIXED64 => compute_fixed64_size(field, json_value),
1245        // fixed32
1246        Type::TYPE_FIXED32 => compute_fixed32_size(field, json_value),
1247        // u32
1248        Type::TYPE_UINT32 => compute_uint32_size(field, json_value),
1249        // enum
1250        Type::TYPE_ENUM => compute_enum_size(field, json_value),
1251        // sfixed32
1252        Type::TYPE_SFIXED32 => compute_sfixed32_size(field, json_value),
1253        // sfixed64
1254        Type::TYPE_SFIXED64 => compute_sfixed64_size(field, json_value),
1255        // sint32
1256        Type::TYPE_SINT32 => compute_sint32_size(field, json_value),
1257        // sint64
1258        Type::TYPE_SINT64 => compute_sint64_size(field, json_value),
1259        // double
1260        Type::TYPE_DOUBLE => compute_double_size(field, json_value),
1261        //
1262        Type::TYPE_FLOAT => compute_float_size(field, json_value),
1263        //
1264        Type::TYPE_STRING => compute_string_size(field, json_value),
1265        // 对象
1266        Type::TYPE_MESSAGE => compute_object_size(field, json_value, service_api_descriptor),
1267        // 对象
1268        Type::TYPE_BOOL => compute_bool_size(field, json_value),
1269        //
1270        _ => {
1271            return Err(Status::error(format!("无消息 描述信息！")));
1272        }
1273    }
1274}
1275
1276//
1277
1278pub fn compute_size(
1279    json_obj: &Value,
1280    msg_name: &str,
1281    service_api_descriptor: &ServiceApiDescriptor,
1282) -> Result<u64, Status> {
1283    let mut buffer_size = 0;
1284    let message_descriptor_holder = service_api_descriptor
1285        .message_descriptor_holder
1286        .get(msg_name);
1287
1288    if message_descriptor_holder.is_none() {
1289        return Err(Status::error(format!("无消息：{} 描述信息！", msg_name)));
1290    }
1291    let msg_descriptor = &message_descriptor_holder.unwrap().descriptor_proto;
1292
1293    for field in &msg_descriptor.field {
1294        let field_name = field.name.as_ref().unwrap();
1295        let json_value = json_obj.get(field_name);
1296        if json_value.is_none() {
1297            continue;
1298        }
1299
1300        let json_value = json_value.unwrap();
1301        let field_type = field.type_.unwrap().unwrap();
1302
1303        if field_type == Type::TYPE_MESSAGE && is_map(field, service_api_descriptor) {
1304            if !json_value.is_object() {
1305                return Err(Status::error(format!("{} 类型错误，应为 obj", msg_name)));
1306            }
1307
1308            let map_type_name = field.type_name.as_ref().unwrap();
1309
1310            let map_msg_descriptor_holder = service_api_descriptor
1311                .message_descriptor_holder
1312                .get(map_type_name);
1313
1314            let message_descriptor = &map_msg_descriptor_holder.unwrap().descriptor_proto;
1315
1316            let key_field = message_descriptor.field.get(0).unwrap();
1317
1318            let value_field = message_descriptor.field.get(1).unwrap();
1319
1320            let key_field_type = key_field.type_.unwrap().unwrap();
1321
1322            let value_field_type = value_field.type_.unwrap().unwrap();
1323            //
1324
1325            let obj_value = json_value.as_object().unwrap();
1326
1327            for (key, value) in obj_value {
1328                let mut entry_size = 0;
1329                entry_size += compute_json_key_size(key_field_type, key)?;
1330
1331                entry_size += compute_size_inner(
1332                    value_field_type,
1333                    value_field,
1334                    service_api_descriptor,
1335                    value,
1336                )?;
1337                buffer_size +=
1338                    2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size;
1339            }
1340        } else {
1341            buffer_size +=
1342                compute_size_inner(field_type, field, service_api_descriptor, json_value)?;
1343        }
1344    }
1345
1346    Ok(buffer_size)
1347}
1348
1349fn write_json_key(
1350    field_type: Type,
1351    key: &str,
1352    output_stream: &mut CodedOutputStream,
1353) -> Result<(), Status> {
1354    match field_type {
1355        Type::TYPE_DOUBLE => {
1356            let value: Result<f64, _> = key.parse();
1357            output_stream.write_double(1, value.unwrap()).unwrap();
1358        }
1359        Type::TYPE_FLOAT => {
1360            let value: Result<f32, _> = key.parse();
1361            output_stream.write_float(1, value.unwrap()).unwrap();
1362        }
1363        Type::TYPE_INT64 => {
1364            let value: Result<i64, _> = key.parse();
1365            output_stream.write_int64(1, value.unwrap()).unwrap();
1366        }
1367        Type::TYPE_UINT64 => {
1368            let value: Result<u64, _> = key.parse();
1369            output_stream.write_uint64(1, value.unwrap()).unwrap();
1370        }
1371        Type::TYPE_INT32 => {
1372            let value: Result<i32, _> = key.parse();
1373            output_stream.write_int32(1, value.unwrap()).unwrap();
1374        }
1375        Type::TYPE_FIXED64 => {
1376            let value: Result<u64, _> = key.parse();
1377            output_stream.write_fixed64(1, value.unwrap()).unwrap();
1378        }
1379        Type::TYPE_FIXED32 => {
1380            let value: Result<u32, _> = key.parse();
1381            output_stream.write_fixed32(1, value.unwrap()).unwrap();
1382        }
1383        Type::TYPE_BOOL => {
1384            let value: Result<bool, _> = key.parse();
1385            output_stream.write_bool(1, value.unwrap()).unwrap();
1386        }
1387        Type::TYPE_STRING => {
1388            output_stream.write_string(1, key).unwrap();
1389        }
1390        Type::TYPE_UINT32 => {
1391            let value: Result<u32, _> = key.parse();
1392            output_stream.write_uint32(1, value.unwrap()).unwrap();
1393        }
1394        Type::TYPE_SFIXED32 => {
1395            let value: Result<i32, _> = key.parse();
1396            output_stream.write_sfixed32(1, value.unwrap()).unwrap();
1397        }
1398        Type::TYPE_SFIXED64 => {
1399            let value: Result<i64, _> = key.parse();
1400            output_stream.write_sfixed64(1, value.unwrap()).unwrap();
1401        }
1402        Type::TYPE_SINT32 => {
1403            let value: Result<i32, _> = key.parse();
1404            output_stream.write_sint32(1, value.unwrap()).unwrap();
1405        }
1406        Type::TYPE_SINT64 => {
1407            let value: Result<i64, _> = key.parse();
1408            output_stream.write_sint64(1, value.unwrap()).unwrap();
1409        }
1410        _ => {
1411            return Err(Status::error(format!("无消息 描述信息！")));
1412        }
1413    };
1414    Ok(())
1415}
1416
1417fn json_to_proto_with_buffer_inner(
1418    field_type: Type,
1419    field: &FieldDescriptorProto,
1420    json_value: &Value,
1421    service_api_descriptor: &ServiceApiDescriptor,
1422    output_stream: &mut CodedOutputStream,
1423) -> Result<(), Status> {
1424    match field_type {
1425        // i64
1426        Type::TYPE_INT64 => write_int64(field, json_value, output_stream),
1427        // ui64
1428        Type::TYPE_UINT64 => write_uint64(field, json_value, output_stream),
1429        // i32
1430        Type::TYPE_INT32 => write_int32(field, json_value, output_stream),
1431        // fixed64
1432        Type::TYPE_FIXED64 => write_fixed64(field, json_value, output_stream),
1433        // fixed32
1434        Type::TYPE_FIXED32 => write_fixed32(field, json_value, output_stream),
1435        // u32
1436        Type::TYPE_UINT32 => write_uint32(field, json_value, output_stream),
1437        // enum
1438        Type::TYPE_ENUM => write_enum(field, json_value, output_stream),
1439        // sfixed32
1440        Type::TYPE_SFIXED32 => write_sfixed32(field, json_value, output_stream),
1441        // sfixed64
1442        Type::TYPE_SFIXED64 => write_sfixed64(field, json_value, output_stream),
1443        // sint32
1444        Type::TYPE_SINT32 => write_sint32(field, json_value, output_stream),
1445        // sint64
1446        Type::TYPE_SINT64 => write_sint64(field, json_value, output_stream),
1447        // double
1448        Type::TYPE_DOUBLE => write_double(field, json_value, output_stream),
1449        //
1450        Type::TYPE_FLOAT => write_float(field, json_value, output_stream),
1451        //
1452        Type::TYPE_STRING => write_string(field, json_value, output_stream),
1453        // 对象
1454        Type::TYPE_MESSAGE => {
1455            write_object(field, json_value, service_api_descriptor, output_stream)
1456        }
1457        // 对象
1458        Type::TYPE_BOOL => write_bool(field, json_value, output_stream),
1459        //
1460        _ => Err(Status::error("类型错误！".into())),
1461    }
1462}
1463
1464pub fn json_to_proto_with_buffer(
1465    json_obj: &Value,
1466    msg_name: &str,
1467    service_api_descriptor: &ServiceApiDescriptor,
1468    output_stream: &mut CodedOutputStream,
1469) -> Result<(), Status> {
1470    let msg_descriptor_holder = service_api_descriptor
1471        .message_descriptor_holder
1472        .get(msg_name);
1473
1474    let msg_descriptor = &msg_descriptor_holder.unwrap().descriptor_proto;
1475
1476    for field in &msg_descriptor.field {
1477        let field_name = field.name.as_ref().unwrap();
1478
1479        let json_value = json_obj.get(field_name);
1480
1481        if json_value.is_none() {
1482            continue;
1483        }
1484        let json_value = json_value.unwrap();
1485        let field_type = field.type_.unwrap().unwrap();
1486
1487        if field_type == Type::TYPE_MESSAGE && is_map(field, service_api_descriptor) {
1488            let map_type_name = field.type_name.as_ref().unwrap();
1489
1490            let map_msg_descriptor_holder = service_api_descriptor
1491                .message_descriptor_holder
1492                .get(map_type_name);
1493
1494            let message_descriptor = &map_msg_descriptor_holder.unwrap().descriptor_proto;
1495
1496            let key_field = message_descriptor.field.get(0).unwrap();
1497
1498            let value_field = message_descriptor.field.get(1).unwrap();
1499
1500            let key_field_type = key_field.type_.unwrap().unwrap();
1501
1502            let value_field_type = value_field.type_.unwrap().unwrap();
1503            //
1504            let obj_value = json_value.as_object().unwrap();
1505
1506            let number = field.number() as u32;
1507
1508            let wire_type = get_wire_type(field);
1509
1510            let tag = make_tag(number, wire_type);
1511
1512            for (key, value) in obj_value {
1513                let mut entry_size = 0;
1514                entry_size += compute_json_key_size(key_field_type, key)?;
1515                entry_size += compute_size_inner(
1516                    value_field_type,
1517                    value_field,
1518                    service_api_descriptor,
1519                    value,
1520                )?;
1521                output_stream.write_raw_varint32(tag).unwrap();
1522                output_stream.write_raw_varint32(entry_size as u32).unwrap();
1523                // 写入key
1524                write_json_key(key_field_type, key, output_stream)?;
1525
1526                // 写入 value
1527                json_to_proto_with_buffer_inner(
1528                    value_field_type,
1529                    value_field,
1530                    value,
1531                    service_api_descriptor,
1532                    output_stream,
1533                )?
1534            }
1535        } else {
1536            json_to_proto_with_buffer_inner(
1537                field_type,
1538                field,
1539                json_value,
1540                service_api_descriptor,
1541                output_stream,
1542            )?
1543        }
1544    }
1545    Ok(())
1546}
1547
1548pub fn json_to_proto(
1549    json: &str,
1550    msg_name: &str,
1551    service_api_descriptor: &ServiceApiDescriptor,
1552) -> Result<Vec<u8>, Status> {
1553    let json_obj: Result<Value, _> = serde_json::from_str(json);
1554
1555    if json_obj.is_err() {
1556        return Err(Status::error(json_obj.err().unwrap().to_string()));
1557    }
1558    let json_obj = json_obj.as_ref().unwrap();
1559
1560    json_value_to_proto(json_obj, msg_name, service_api_descriptor)
1561}
1562
1563pub fn json_value_to_proto(
1564    json_value: &Value,
1565    msg_name: &str,
1566    service_api_descriptor: &ServiceApiDescriptor,
1567) -> Result<Vec<u8>, Status> {
1568    let buffer_size = compute_size(json_value, msg_name, service_api_descriptor)?;
1569    let mut buffer = Vec::with_capacity(buffer_size as usize);
1570
1571    let mut output_stream = CodedOutputStream::vec(&mut buffer);
1572
1573    json_to_proto_with_buffer(
1574        json_value,
1575        msg_name,
1576        service_api_descriptor,
1577        &mut output_stream,
1578    )?;
1579
1580    let flush_result = output_stream.flush();
1581
1582    if flush_result.is_err() {
1583        return Err(Status::error(flush_result.err().unwrap().to_string()));
1584    }
1585    drop(output_stream);
1586
1587    Ok(buffer)
1588}
xCommonLib/serial/json_to_proto.rs

xCommonLib/serial/
json_to_proto.rs
