1use std::collections::{BTreeMap, HashMap, VecDeque};
2use std::fmt;
3
4use pax_message::serde::de::{
5 self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess,
6 Visitor,
7};
8use pax_message::serde::ser::{
9 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
10 SerializeTupleStruct, SerializeTupleVariant,
11};
12use pax_message::serde::{Deserialize, Serialize};
13
14use crate::{
15 ComponentDefinition, ComponentTemplate, PaxManifest, RouteBranchDescriptor,
16 SettingsBlockElement, TemplateNodeDefinition, TemplateNodeId, TimelineDefinition,
17 TypeDefinition, TypeId,
18};
19
20const MAGIC: &[u8; 8] = b"PAXM\x00BIN";
21const VERSION: u8 = 6;
23
24pub type Result<T> = std::result::Result<T, Error>;
25
26#[derive(Debug)]
27pub struct Error {
28 message: String,
29}
30
31impl Error {
32 fn message(message: impl fmt::Display) -> Self {
33 Self {
34 message: message.to_string(),
35 }
36 }
37}
38
39impl fmt::Display for Error {
40 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41 f.write_str(&self.message)
42 }
43}
44
45impl std::error::Error for Error {}
46
47impl ser::Error for Error {
48 fn custom<T>(message: T) -> Self
49 where
50 T: fmt::Display,
51 {
52 Error::message(message)
53 }
54}
55
56impl de::Error for Error {
57 fn custom<T>(message: T) -> Self
58 where
59 T: fmt::Display,
60 {
61 Error::message(message)
62 }
63}
64
65#[derive(Serialize, Deserialize)]
66#[serde(crate = "pax_message::serde")]
67struct BinaryPaxManifest {
68 components: Vec<(TypeId, BinaryComponentDefinition)>,
69 main_component_type_id: TypeId,
70 type_table: Vec<(TypeId, TypeDefinition)>,
71 assets_dirs: Vec<String>,
72 engine_import_path: String,
73}
74
75#[derive(Serialize, Deserialize)]
76#[serde(crate = "pax_message::serde")]
77struct BinaryComponentDefinition {
78 type_id: TypeId,
79 is_main_component: bool,
80 is_primitive: bool,
81 is_struct_only_component: bool,
82 module_path: String,
83 primitive_instance_import_path: Option<String>,
84 template: Option<BinaryComponentTemplate>,
85 settings: Option<Vec<SettingsBlockElement>>,
86 timelines: Vec<TimelineDefinition>,
87 route_branch: Option<RouteBranchDescriptor>,
88}
89
90#[derive(Serialize, Deserialize)]
91#[serde(crate = "pax_message::serde")]
92struct BinaryComponentTemplate {
93 containing_component: TypeId,
94 root: VecDeque<TemplateNodeId>,
95 children: Vec<(TemplateNodeId, VecDeque<TemplateNodeId>)>,
96 nodes: Vec<(TemplateNodeId, TemplateNodeDefinition)>,
97 next_id: usize,
98 template_source_file_path: Option<String>,
99}
100
101impl From<&PaxManifest> for BinaryPaxManifest {
102 fn from(manifest: &PaxManifest) -> Self {
103 let components = manifest
104 .components
105 .iter()
106 .map(|(type_id, definition)| {
107 (type_id.clone(), BinaryComponentDefinition::from(definition))
108 })
109 .collect();
110
111 let mut type_table = manifest
112 .type_table
113 .iter()
114 .map(|(type_id, definition)| (type_id.clone(), definition.clone()))
115 .collect::<Vec<_>>();
116 type_table.sort_by(|a, b| a.0.cmp(&b.0));
117
118 Self {
119 components,
120 main_component_type_id: manifest.main_component_type_id.clone(),
121 type_table,
122 assets_dirs: manifest.assets_dirs.clone(),
123 engine_import_path: manifest.engine_import_path.clone(),
124 }
125 }
126}
127
128impl BinaryPaxManifest {
129 fn into_manifest(self) -> PaxManifest {
130 PaxManifest {
131 components: self
132 .components
133 .into_iter()
134 .map(|(type_id, definition)| (type_id, definition.into_component_definition()))
135 .collect::<BTreeMap<_, _>>(),
136 main_component_type_id: self.main_component_type_id,
137 type_table: self.type_table.into_iter().collect::<HashMap<_, _>>(),
138 assets_dirs: self.assets_dirs,
139 engine_import_path: self.engine_import_path,
140 }
141 }
142}
143
144impl From<&ComponentDefinition> for BinaryComponentDefinition {
145 fn from(definition: &ComponentDefinition) -> Self {
146 Self {
147 type_id: definition.type_id.clone(),
148 is_main_component: definition.is_main_component,
149 is_primitive: definition.is_primitive,
150 is_struct_only_component: definition.is_struct_only_component,
151 module_path: definition.module_path.clone(),
152 primitive_instance_import_path: definition.primitive_instance_import_path.clone(),
153 template: definition
154 .template
155 .as_ref()
156 .map(BinaryComponentTemplate::from),
157 settings: definition.settings.clone(),
158 timelines: definition.timelines.clone(),
159 route_branch: definition.route_branch.clone(),
160 }
161 }
162}
163
164impl BinaryComponentDefinition {
165 fn into_component_definition(self) -> ComponentDefinition {
166 ComponentDefinition {
167 type_id: self.type_id,
168 is_main_component: self.is_main_component,
169 is_primitive: self.is_primitive,
170 is_struct_only_component: self.is_struct_only_component,
171 module_path: self.module_path,
172 primitive_instance_import_path: self.primitive_instance_import_path,
173 template: self
174 .template
175 .map(BinaryComponentTemplate::into_component_template),
176 settings: self.settings,
177 timelines: self.timelines,
178 route_branch: self.route_branch,
179 }
180 }
181}
182
183impl From<&ComponentTemplate> for BinaryComponentTemplate {
184 fn from(template: &ComponentTemplate) -> Self {
185 let mut children = template
186 .children
187 .iter()
188 .map(|(id, children)| (id.clone(), children.clone()))
189 .collect::<Vec<_>>();
190 children.sort_by_key(|(id, _)| id.as_usize());
191
192 let mut nodes = template
193 .nodes
194 .iter()
195 .map(|(id, node)| (id.clone(), node.clone()))
196 .collect::<Vec<_>>();
197 nodes.sort_by_key(|(id, _)| id.as_usize());
198
199 Self {
200 containing_component: template.containing_component.clone(),
201 root: template.root.clone(),
202 children,
203 nodes,
204 next_id: template.next_id,
205 template_source_file_path: template.template_source_file_path.clone(),
206 }
207 }
208}
209
210impl BinaryComponentTemplate {
211 fn into_component_template(self) -> ComponentTemplate {
212 ComponentTemplate {
213 containing_component: self.containing_component,
214 root: self.root,
215 children: self.children.into_iter().collect::<HashMap<_, _>>(),
216 nodes: self.nodes.into_iter().collect::<HashMap<_, _>>(),
217 next_id: self.next_id,
218 template_source_file_path: self.template_source_file_path,
219 }
220 }
221}
222
223pub(crate) fn encode_with_header<T: Serialize>(
224 magic: &[u8; 8],
225 version: u8,
226 value: &T,
227) -> Result<Vec<u8>> {
228 let mut serializer = Serializer::new();
229 serializer.output.extend_from_slice(magic);
230 serializer.output.push(version);
231 value.serialize(&mut serializer)?;
232 Ok(serializer.output)
233}
234
235pub(crate) fn decode_with_header<T>(bytes: &[u8], magic: &[u8; 8], version: u8) -> Result<T>
236where
237 T: for<'de> Deserialize<'de>,
238{
239 if bytes.len() < magic.len() + 1 {
240 return Err(Error::message("binary manifest is too short"));
241 }
242 if &bytes[..magic.len()] != magic {
243 return Err(Error::message(
244 "binary manifest has an invalid magic header",
245 ));
246 }
247 let actual_version = bytes[magic.len()];
248 if actual_version != version {
249 return Err(Error::message(format!(
250 "unsupported binary manifest version {actual_version}"
251 )));
252 }
253
254 let mut deserializer = Deserializer::new(&bytes[magic.len() + 1..]);
255 let value = T::deserialize(&mut deserializer)?;
256 if !deserializer.is_finished() {
257 return Err(Error::message("binary manifest has trailing bytes"));
258 }
259 Ok(value)
260}
261
262pub fn to_vec(manifest: &PaxManifest) -> Result<Vec<u8>> {
263 let wire_manifest = BinaryPaxManifest::from(manifest);
264 encode_with_header(MAGIC, VERSION, &wire_manifest)
265}
266
267pub fn from_slice(bytes: &[u8]) -> Result<PaxManifest> {
268 let wire_manifest: BinaryPaxManifest = decode_with_header(bytes, MAGIC, VERSION)?;
269 Ok(wire_manifest.into_manifest())
270}
271
272struct Serializer {
273 output: Vec<u8>,
274}
275
276impl Serializer {
277 fn new() -> Self {
278 Self { output: Vec::new() }
279 }
280
281 fn write_byte(&mut self, value: u8) {
282 self.output.push(value);
283 }
284
285 fn write_all(&mut self, bytes: &[u8]) {
286 self.output.extend_from_slice(bytes);
287 }
288
289 fn write_u64(&mut self, mut value: u64) {
290 while value >= 0x80 {
291 self.write_byte((value as u8) | 0x80);
292 value >>= 7;
293 }
294 self.write_byte(value as u8);
295 }
296
297 fn write_i64(&mut self, value: i64) {
298 let encoded = ((value << 1) ^ (value >> 63)) as u64;
299 self.write_u64(encoded);
300 }
301
302 fn write_len(&mut self, len: Option<usize>) -> Result<()> {
303 let len = len.ok_or_else(|| Error::message("binary manifest requires known lengths"))?;
304 self.write_u64(len as u64);
305 Ok(())
306 }
307}
308
309impl<'a> ser::Serializer for &'a mut Serializer {
310 type Ok = ();
311 type Error = Error;
312 type SerializeSeq = Compound<'a>;
313 type SerializeTuple = Compound<'a>;
314 type SerializeTupleStruct = Compound<'a>;
315 type SerializeTupleVariant = Compound<'a>;
316 type SerializeMap = Compound<'a>;
317 type SerializeStruct = Compound<'a>;
318 type SerializeStructVariant = Compound<'a>;
319
320 fn serialize_bool(self, value: bool) -> Result<()> {
321 self.write_byte(u8::from(value));
322 Ok(())
323 }
324
325 fn serialize_i8(self, value: i8) -> Result<()> {
326 self.write_i64(value as i64);
327 Ok(())
328 }
329
330 fn serialize_i16(self, value: i16) -> Result<()> {
331 self.write_i64(value as i64);
332 Ok(())
333 }
334
335 fn serialize_i32(self, value: i32) -> Result<()> {
336 self.write_i64(value as i64);
337 Ok(())
338 }
339
340 fn serialize_i64(self, value: i64) -> Result<()> {
341 self.write_i64(value);
342 Ok(())
343 }
344
345 fn serialize_u8(self, value: u8) -> Result<()> {
346 self.write_u64(value as u64);
347 Ok(())
348 }
349
350 fn serialize_u16(self, value: u16) -> Result<()> {
351 self.write_u64(value as u64);
352 Ok(())
353 }
354
355 fn serialize_u32(self, value: u32) -> Result<()> {
356 self.write_u64(value as u64);
357 Ok(())
358 }
359
360 fn serialize_u64(self, value: u64) -> Result<()> {
361 self.write_u64(value);
362 Ok(())
363 }
364
365 fn serialize_f32(self, value: f32) -> Result<()> {
366 self.write_all(&value.to_le_bytes());
367 Ok(())
368 }
369
370 fn serialize_f64(self, value: f64) -> Result<()> {
371 self.write_all(&value.to_le_bytes());
372 Ok(())
373 }
374
375 fn serialize_char(self, value: char) -> Result<()> {
376 self.write_u64(value as u32 as u64);
377 Ok(())
378 }
379
380 fn serialize_str(self, value: &str) -> Result<()> {
381 self.write_u64(value.len() as u64);
382 self.write_all(value.as_bytes());
383 Ok(())
384 }
385
386 fn serialize_bytes(self, value: &[u8]) -> Result<()> {
387 self.write_u64(value.len() as u64);
388 self.write_all(value);
389 Ok(())
390 }
391
392 fn serialize_none(self) -> Result<()> {
393 self.write_byte(0);
394 Ok(())
395 }
396
397 fn serialize_some<T>(self, value: &T) -> Result<()>
398 where
399 T: ?Sized + Serialize,
400 {
401 self.write_byte(1);
402 value.serialize(self)
403 }
404
405 fn serialize_unit(self) -> Result<()> {
406 Ok(())
407 }
408
409 fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
410 Ok(())
411 }
412
413 fn serialize_unit_variant(
414 self,
415 _name: &'static str,
416 variant_index: u32,
417 _variant: &'static str,
418 ) -> Result<()> {
419 self.write_u64(variant_index as u64);
420 Ok(())
421 }
422
423 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
424 where
425 T: ?Sized + Serialize,
426 {
427 value.serialize(self)
428 }
429
430 fn serialize_newtype_variant<T>(
431 self,
432 _name: &'static str,
433 variant_index: u32,
434 _variant: &'static str,
435 value: &T,
436 ) -> Result<()>
437 where
438 T: ?Sized + Serialize,
439 {
440 self.write_u64(variant_index as u64);
441 value.serialize(self)
442 }
443
444 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
445 self.write_len(len)?;
446 Ok(Compound { serializer: self })
447 }
448
449 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
450 Ok(Compound { serializer: self })
451 }
452
453 fn serialize_tuple_struct(
454 self,
455 _name: &'static str,
456 _len: usize,
457 ) -> Result<Self::SerializeTupleStruct> {
458 Ok(Compound { serializer: self })
459 }
460
461 fn serialize_tuple_variant(
462 self,
463 _name: &'static str,
464 variant_index: u32,
465 _variant: &'static str,
466 _len: usize,
467 ) -> Result<Self::SerializeTupleVariant> {
468 self.write_u64(variant_index as u64);
469 Ok(Compound { serializer: self })
470 }
471
472 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
473 self.write_len(len)?;
474 Ok(Compound { serializer: self })
475 }
476
477 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
478 Ok(Compound { serializer: self })
479 }
480
481 fn serialize_struct_variant(
482 self,
483 _name: &'static str,
484 variant_index: u32,
485 _variant: &'static str,
486 _len: usize,
487 ) -> Result<Self::SerializeStructVariant> {
488 self.write_u64(variant_index as u64);
489 Ok(Compound { serializer: self })
490 }
491}
492
493struct Compound<'a> {
494 serializer: &'a mut Serializer,
495}
496
497impl<'a> SerializeSeq for Compound<'a> {
498 type Ok = ();
499 type Error = Error;
500
501 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
502 where
503 T: ?Sized + Serialize,
504 {
505 value.serialize(&mut *self.serializer)
506 }
507
508 fn end(self) -> Result<()> {
509 Ok(())
510 }
511}
512
513impl<'a> SerializeTuple for Compound<'a> {
514 type Ok = ();
515 type Error = Error;
516
517 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
518 where
519 T: ?Sized + Serialize,
520 {
521 value.serialize(&mut *self.serializer)
522 }
523
524 fn end(self) -> Result<()> {
525 Ok(())
526 }
527}
528
529impl<'a> SerializeTupleStruct for Compound<'a> {
530 type Ok = ();
531 type Error = Error;
532
533 fn serialize_field<T>(&mut self, value: &T) -> Result<()>
534 where
535 T: ?Sized + Serialize,
536 {
537 value.serialize(&mut *self.serializer)
538 }
539
540 fn end(self) -> Result<()> {
541 Ok(())
542 }
543}
544
545impl<'a> SerializeTupleVariant for Compound<'a> {
546 type Ok = ();
547 type Error = Error;
548
549 fn serialize_field<T>(&mut self, value: &T) -> Result<()>
550 where
551 T: ?Sized + Serialize,
552 {
553 value.serialize(&mut *self.serializer)
554 }
555
556 fn end(self) -> Result<()> {
557 Ok(())
558 }
559}
560
561impl<'a> SerializeMap for Compound<'a> {
562 type Ok = ();
563 type Error = Error;
564
565 fn serialize_key<T>(&mut self, key: &T) -> Result<()>
566 where
567 T: ?Sized + Serialize,
568 {
569 key.serialize(&mut *self.serializer)
570 }
571
572 fn serialize_value<T>(&mut self, value: &T) -> Result<()>
573 where
574 T: ?Sized + Serialize,
575 {
576 value.serialize(&mut *self.serializer)
577 }
578
579 fn end(self) -> Result<()> {
580 Ok(())
581 }
582}
583
584impl<'a> SerializeStruct for Compound<'a> {
585 type Ok = ();
586 type Error = Error;
587
588 fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
589 where
590 T: ?Sized + Serialize,
591 {
592 value.serialize(&mut *self.serializer)
593 }
594
595 fn end(self) -> Result<()> {
596 Ok(())
597 }
598}
599
600impl<'a> SerializeStructVariant for Compound<'a> {
601 type Ok = ();
602 type Error = Error;
603
604 fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
605 where
606 T: ?Sized + Serialize,
607 {
608 value.serialize(&mut *self.serializer)
609 }
610
611 fn end(self) -> Result<()> {
612 Ok(())
613 }
614}
615
616struct Deserializer<'de> {
617 input: &'de [u8],
618 offset: usize,
619}
620
621impl<'de> Deserializer<'de> {
622 fn new(input: &'de [u8]) -> Self {
623 Self { input, offset: 0 }
624 }
625
626 fn is_finished(&self) -> bool {
627 self.offset == self.input.len()
628 }
629
630 fn read_byte(&mut self) -> Result<u8> {
631 let byte = self
632 .input
633 .get(self.offset)
634 .copied()
635 .ok_or_else(|| Error::message("unexpected end of binary manifest"))?;
636 self.offset += 1;
637 Ok(byte)
638 }
639
640 fn read_exact(&mut self, len: usize) -> Result<&'de [u8]> {
641 let end = self
642 .offset
643 .checked_add(len)
644 .ok_or_else(|| Error::message("binary manifest offset overflow"))?;
645 if end > self.input.len() {
646 return Err(Error::message("unexpected end of binary manifest"));
647 }
648 let bytes = &self.input[self.offset..end];
649 self.offset = end;
650 Ok(bytes)
651 }
652
653 fn read_u64(&mut self) -> Result<u64> {
654 let mut value = 0u64;
655 let mut shift = 0u32;
656 loop {
657 let byte = self.read_byte()?;
658 value |= ((byte & 0x7f) as u64) << shift;
659 if byte & 0x80 == 0 {
660 return Ok(value);
661 }
662 shift += 7;
663 if shift >= 64 {
664 return Err(Error::message("invalid varint in binary manifest"));
665 }
666 }
667 }
668
669 fn read_i64(&mut self) -> Result<i64> {
670 let value = self.read_u64()?;
671 Ok(((value >> 1) as i64) ^ (-((value & 1) as i64)))
672 }
673
674 fn read_len(&mut self) -> Result<usize> {
675 let value = self.read_u64()?;
676 usize::try_from(value).map_err(|_| Error::message("manifest length overflows usize"))
677 }
678}
679
680impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
681 type Error = Error;
682
683 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
684 where
685 V: Visitor<'de>,
686 {
687 Err(Error::message(
688 "binary manifest deserializer is not self-describing",
689 ))
690 }
691
692 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
693 where
694 V: Visitor<'de>,
695 {
696 match self.read_byte()? {
697 0 => visitor.visit_bool(false),
698 1 => visitor.visit_bool(true),
699 other => Err(Error::message(format!("invalid bool tag {other}"))),
700 }
701 }
702
703 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
704 where
705 V: Visitor<'de>,
706 {
707 let value = self.read_i64()?;
708 let value = i8::try_from(value).map_err(|_| Error::message("i8 out of range"))?;
709 visitor.visit_i8(value)
710 }
711
712 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
713 where
714 V: Visitor<'de>,
715 {
716 let value = self.read_i64()?;
717 let value = i16::try_from(value).map_err(|_| Error::message("i16 out of range"))?;
718 visitor.visit_i16(value)
719 }
720
721 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
722 where
723 V: Visitor<'de>,
724 {
725 let value = self.read_i64()?;
726 let value = i32::try_from(value).map_err(|_| Error::message("i32 out of range"))?;
727 visitor.visit_i32(value)
728 }
729
730 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
731 where
732 V: Visitor<'de>,
733 {
734 visitor.visit_i64(self.read_i64()?)
735 }
736
737 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
738 where
739 V: Visitor<'de>,
740 {
741 let value = self.read_u64()?;
742 let value = u8::try_from(value).map_err(|_| Error::message("u8 out of range"))?;
743 visitor.visit_u8(value)
744 }
745
746 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
747 where
748 V: Visitor<'de>,
749 {
750 let value = self.read_u64()?;
751 let value = u16::try_from(value).map_err(|_| Error::message("u16 out of range"))?;
752 visitor.visit_u16(value)
753 }
754
755 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
756 where
757 V: Visitor<'de>,
758 {
759 let value = self.read_u64()?;
760 let value = u32::try_from(value).map_err(|_| Error::message("u32 out of range"))?;
761 visitor.visit_u32(value)
762 }
763
764 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
765 where
766 V: Visitor<'de>,
767 {
768 visitor.visit_u64(self.read_u64()?)
769 }
770
771 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
772 where
773 V: Visitor<'de>,
774 {
775 let mut bytes = [0u8; 4];
776 bytes.copy_from_slice(self.read_exact(4)?);
777 visitor.visit_f32(f32::from_le_bytes(bytes))
778 }
779
780 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
781 where
782 V: Visitor<'de>,
783 {
784 let mut bytes = [0u8; 8];
785 bytes.copy_from_slice(self.read_exact(8)?);
786 visitor.visit_f64(f64::from_le_bytes(bytes))
787 }
788
789 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
790 where
791 V: Visitor<'de>,
792 {
793 let value = self.read_u64()?;
794 let value = u32::try_from(value).map_err(|_| Error::message("char out of range"))?;
795 let value = char::from_u32(value).ok_or_else(|| Error::message("invalid char scalar"))?;
796 visitor.visit_char(value)
797 }
798
799 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
800 where
801 V: Visitor<'de>,
802 {
803 let len = self.read_len()?;
804 let bytes = self.read_exact(len)?;
805 let value = std::str::from_utf8(bytes)
806 .map_err(|err| Error::message(format!("invalid UTF-8 string: {err}")))?;
807 visitor.visit_borrowed_str(value)
808 }
809
810 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
811 where
812 V: Visitor<'de>,
813 {
814 self.deserialize_str(visitor)
815 }
816
817 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
818 where
819 V: Visitor<'de>,
820 {
821 let len = self.read_len()?;
822 visitor.visit_borrowed_bytes(self.read_exact(len)?)
823 }
824
825 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
826 where
827 V: Visitor<'de>,
828 {
829 let len = self.read_len()?;
830 visitor.visit_byte_buf(self.read_exact(len)?.to_vec())
831 }
832
833 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
834 where
835 V: Visitor<'de>,
836 {
837 match self.read_byte()? {
838 0 => visitor.visit_none(),
839 1 => visitor.visit_some(self),
840 other => Err(Error::message(format!("invalid option tag {other}"))),
841 }
842 }
843
844 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
845 where
846 V: Visitor<'de>,
847 {
848 visitor.visit_unit()
849 }
850
851 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
852 where
853 V: Visitor<'de>,
854 {
855 visitor.visit_unit()
856 }
857
858 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
859 where
860 V: Visitor<'de>,
861 {
862 visitor.visit_newtype_struct(self)
863 }
864
865 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
866 where
867 V: Visitor<'de>,
868 {
869 let len = self.read_len()?;
870 visitor.visit_seq(SequenceAccess {
871 deserializer: self,
872 remaining: len,
873 })
874 }
875
876 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
877 where
878 V: Visitor<'de>,
879 {
880 visitor.visit_seq(SequenceAccess {
881 deserializer: self,
882 remaining: len,
883 })
884 }
885
886 fn deserialize_tuple_struct<V>(
887 self,
888 _name: &'static str,
889 len: usize,
890 visitor: V,
891 ) -> Result<V::Value>
892 where
893 V: Visitor<'de>,
894 {
895 self.deserialize_tuple(len, visitor)
896 }
897
898 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
899 where
900 V: Visitor<'de>,
901 {
902 let len = self.read_len()?;
903 visitor.visit_map(BinaryMapAccess {
904 deserializer: self,
905 remaining: len,
906 })
907 }
908
909 fn deserialize_struct<V>(
910 self,
911 _name: &'static str,
912 fields: &'static [&'static str],
913 visitor: V,
914 ) -> Result<V::Value>
915 where
916 V: Visitor<'de>,
917 {
918 visitor.visit_seq(SequenceAccess {
919 deserializer: self,
920 remaining: fields.len(),
921 })
922 }
923
924 fn deserialize_enum<V>(
925 self,
926 _name: &'static str,
927 _variants: &'static [&'static str],
928 visitor: V,
929 ) -> Result<V::Value>
930 where
931 V: Visitor<'de>,
932 {
933 let variant_index = self.read_u64()?;
934 let variant_index =
935 u32::try_from(variant_index).map_err(|_| Error::message("enum index out of range"))?;
936 visitor.visit_enum(BinaryEnumAccess {
937 deserializer: self,
938 variant_index,
939 })
940 }
941
942 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
943 where
944 V: Visitor<'de>,
945 {
946 self.deserialize_u32(visitor)
947 }
948
949 fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
950 where
951 V: Visitor<'de>,
952 {
953 Err(Error::message(
954 "binary manifest cannot skip unknown values without type information",
955 ))
956 }
957
958 fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
959 where
960 V: Visitor<'de>,
961 {
962 let value = self.read_i64()?;
963 visitor.visit_i128(value as i128)
964 }
965
966 fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
967 where
968 V: Visitor<'de>,
969 {
970 let value = self.read_u64()?;
971 visitor.visit_u128(value as u128)
972 }
973}
974
975struct SequenceAccess<'a, 'de> {
976 deserializer: &'a mut Deserializer<'de>,
977 remaining: usize,
978}
979
980impl<'de, 'a> SeqAccess<'de> for SequenceAccess<'a, 'de> {
981 type Error = Error;
982
983 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
984 where
985 T: DeserializeSeed<'de>,
986 {
987 if self.remaining == 0 {
988 return Ok(None);
989 }
990 self.remaining -= 1;
991 seed.deserialize(&mut *self.deserializer).map(Some)
992 }
993
994 fn size_hint(&self) -> Option<usize> {
995 Some(self.remaining)
996 }
997}
998
999struct BinaryMapAccess<'a, 'de> {
1000 deserializer: &'a mut Deserializer<'de>,
1001 remaining: usize,
1002}
1003
1004impl<'de, 'a> MapAccess<'de> for BinaryMapAccess<'a, 'de> {
1005 type Error = Error;
1006
1007 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1008 where
1009 K: DeserializeSeed<'de>,
1010 {
1011 if self.remaining == 0 {
1012 return Ok(None);
1013 }
1014 seed.deserialize(&mut *self.deserializer).map(Some)
1015 }
1016
1017 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1018 where
1019 V: DeserializeSeed<'de>,
1020 {
1021 self.remaining -= 1;
1022 seed.deserialize(&mut *self.deserializer)
1023 }
1024
1025 fn size_hint(&self) -> Option<usize> {
1026 Some(self.remaining)
1027 }
1028}
1029
1030struct BinaryEnumAccess<'a, 'de> {
1031 deserializer: &'a mut Deserializer<'de>,
1032 variant_index: u32,
1033}
1034
1035impl<'de, 'a> EnumAccess<'de> for BinaryEnumAccess<'a, 'de> {
1036 type Error = Error;
1037 type Variant = BinaryVariantAccess<'a, 'de>;
1038
1039 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
1040 where
1041 V: DeserializeSeed<'de>,
1042 {
1043 let variant = seed.deserialize(self.variant_index.into_deserializer())?;
1044 Ok((
1045 variant,
1046 BinaryVariantAccess {
1047 deserializer: self.deserializer,
1048 },
1049 ))
1050 }
1051}
1052
1053struct BinaryVariantAccess<'a, 'de> {
1054 deserializer: &'a mut Deserializer<'de>,
1055}
1056
1057impl<'de, 'a> VariantAccess<'de> for BinaryVariantAccess<'a, 'de> {
1058 type Error = Error;
1059
1060 fn unit_variant(self) -> Result<()> {
1061 Ok(())
1062 }
1063
1064 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
1065 where
1066 T: DeserializeSeed<'de>,
1067 {
1068 seed.deserialize(self.deserializer)
1069 }
1070
1071 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
1072 where
1073 V: Visitor<'de>,
1074 {
1075 de::Deserializer::deserialize_tuple(self.deserializer, len, visitor)
1076 }
1077
1078 fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
1079 where
1080 V: Visitor<'de>,
1081 {
1082 de::Deserializer::deserialize_tuple(self.deserializer, fields.len(), visitor)
1083 }
1084}
1085
1086#[cfg(test)]
1087mod tests {
1088 use super::*;
1089 use crate::{
1090 GradientDefinition, GradientElement, GradientShapeDefinition, GradientStopDefinition,
1091 PropertyDefinition, SettingElement, Token, TypeTable, ValueDefinition,
1092 };
1093 use pax_runtime_api::{Color, Numeric, PaxValue, Size};
1094
1095 #[test]
1096 fn binary_manifest_round_trips_template_maps_without_json_keys() {
1097 let type_id = TypeId::build_singleton("crate::App", Some("App"));
1098 let mut template = ComponentTemplate::new(type_id.clone(), Some("src/lib.pax".to_string()));
1099
1100 let mut root = TemplateNodeDefinition::default();
1101 root.type_id = type_id.clone();
1102 root.raw_comment_string = Some("root".to_string());
1103 root.selector_info.class_binding =
1104 Some(ValueDefinition::LiteralValue(PaxValue::Vec(vec![
1105 PaxValue::String("card".to_string()),
1106 PaxValue::String("elevated".to_string()),
1107 ])));
1108 root.settings = Some(vec![
1109 SettingElement::Setting(
1110 Token::new_without_location("fill".to_string()),
1111 ValueDefinition::Gradient(GradientDefinition {
1112 shape: GradientShapeDefinition::Linear {
1113 start: None,
1114 end: None,
1115 },
1116 elements: vec![
1117 GradientElement::Stop(GradientStopDefinition {
1118 position: Size::Percent(Numeric::F64(0.0)),
1119 color: ValueDefinition::LiteralValue(PaxValue::Color(Box::new(
1120 Color::RED,
1121 ))),
1122 }),
1123 GradientElement::Stop(GradientStopDefinition {
1124 position: Size::Percent(Numeric::F64(100.0)),
1125 color: ValueDefinition::LiteralValue(PaxValue::Color(Box::new(
1126 Color::BLUE,
1127 ))),
1128 }),
1129 ],
1130 }),
1131 ),
1132 SettingElement::Setting(
1133 Token::new_without_location("corner_radius".to_string()),
1134 ValueDefinition::LiteralValue(PaxValue::Vec(vec![
1135 PaxValue::Numeric(Numeric::F64(12.0)),
1136 PaxValue::Numeric(Numeric::F64(4.0)),
1137 ])),
1138 ),
1139 ]);
1140 let root_id = template.add(root).template_node_id;
1141
1142 let mut child = TemplateNodeDefinition::default();
1143 child.type_id = TypeId::build_comment();
1144 child.raw_comment_string = Some("child".to_string());
1145 template.add_child(root_id, child);
1146
1147 let mut components = BTreeMap::new();
1148 components.insert(
1149 type_id.clone(),
1150 ComponentDefinition {
1151 type_id: type_id.clone(),
1152 is_main_component: true,
1153 is_primitive: false,
1154 is_struct_only_component: false,
1155 module_path: "crate".to_string(),
1156 primitive_instance_import_path: None,
1157 template: Some(template),
1158 settings: None,
1159 timelines: vec![],
1160 route_branch: None,
1161 },
1162 );
1163
1164 let mut type_table = TypeTable::default();
1165 type_table.insert(
1166 type_id.clone(),
1167 TypeDefinition {
1168 type_id: type_id.clone(),
1169 inner_iterable_type_id: None,
1170 property_definitions: vec![PropertyDefinition::primitive_with_name(
1171 "String", "label",
1172 )],
1173 },
1174 );
1175
1176 let manifest = PaxManifest {
1177 components,
1178 main_component_type_id: type_id.clone(),
1179 type_table,
1180 assets_dirs: vec!["assets".to_string()],
1181 engine_import_path: "pax_kit::pax_engine".to_string(),
1182 };
1183
1184 let encoded = to_vec(&manifest).expect("manifest should encode");
1185 let decoded = from_slice(&encoded).expect("manifest should decode");
1186 let decoded_component = decoded.components.get(&type_id).unwrap();
1187 let decoded_template = decoded_component.template.as_ref().unwrap();
1188
1189 #[cfg(feature = "json")]
1190 serde_json::to_value(&decoded).expect("decoded manifest should serialize to json");
1191
1192 assert_eq!(
1193 decoded.main_component_type_id,
1194 manifest.main_component_type_id
1195 );
1196 assert_eq!(decoded.type_table.len(), manifest.type_table.len());
1197 assert_eq!(decoded.assets_dirs, manifest.assets_dirs);
1198 assert_eq!(decoded_template.get_root().len(), 1);
1199 assert_eq!(
1200 decoded_template
1201 .get_children(&TemplateNodeId::build(0))
1202 .unwrap()
1203 .len(),
1204 1
1205 );
1206 let root = decoded_template
1207 .get_node(&TemplateNodeId::build(0))
1208 .expect("root should round-trip");
1209 assert!(matches!(
1210 root.settings
1211 .as_ref()
1212 .and_then(|settings| settings.iter().find(|setting| {
1213 matches!(setting, SettingElement::Setting(token, _) if token.token_value == "fill")
1214 })),
1215 Some(SettingElement::Setting(_, ValueDefinition::Gradient(gradient)))
1216 if matches!(&gradient.shape, GradientShapeDefinition::Linear { start: None, end: None })
1217 && gradient.stops().count() == 2
1218 ));
1219 assert!(matches!(
1220 root.settings.as_ref().and_then(|settings| settings.iter().find(|setting| {
1221 matches!(setting, SettingElement::Setting(token, _) if token.token_value == "corner_radius")
1222 })),
1223 Some(SettingElement::Setting(
1224 _,
1225 ValueDefinition::LiteralValue(PaxValue::Vec(values))
1226 )) if values == &vec![
1227 PaxValue::Numeric(Numeric::F64(12.0)),
1228 PaxValue::Numeric(Numeric::F64(4.0)),
1229 ]
1230 ));
1231 let classes = root.selector_info.literal_classes();
1232 assert_eq!(classes, vec!["card", "elevated"]);
1233 }
1234}