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