compact binary serialization format with built-in compression
kokirigla.de
1mod helper;
2
3use hateno::{Tag, TagKind};
4use serde::{Serialize, Serializer};
5
6use crate::{Error, Result};
7
8pub struct TagSerializer;
9
10impl<'a> Serializer for &'a mut TagSerializer {
11 type Ok = Tag;
12 type Error = Error;
13
14 type SerializeSeq = helper::SerializeVec;
15 type SerializeTuple = helper::SerializeVec;
16 type SerializeTupleStruct = helper::SerializeVec;
17 type SerializeTupleVariant = helper::SerializeTupleVariant;
18 type SerializeMap = helper::SerializeMap;
19 type SerializeStruct = helper::SerializeMap;
20 type SerializeStructVariant = helper::SerializeStructVariant;
21
22 fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
23 Ok(Tag::new_bool(v))
24 }
25
26 fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
27 Ok(Tag::new_i8(v))
28 }
29
30 fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
31 Ok(Tag::new_i16(v))
32 }
33
34 fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
35 Ok(Tag::new_i32(v))
36 }
37
38 fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
39 Ok(Tag::new_i64(v))
40 }
41
42 fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
43 Ok(Tag::new_u8(v))
44 }
45
46 fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
47 Ok(Tag::new_u16(v))
48 }
49
50 fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
51 Ok(Tag::new_u32(v))
52 }
53
54 fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
55 Ok(Tag::new_u64(v))
56 }
57
58 fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
59 Ok(Tag::new_f32(v))
60 }
61
62 fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
63 Ok(Tag::new_f64(v))
64 }
65
66 fn serialize_char(self, v: char) -> Result<Self::Ok> {
67 Ok(Tag::new_string(v.to_string()))
68 }
69
70 fn serialize_str(self, v: &str) -> Result<Self::Ok> {
71 Ok(Tag::new_string(v))
72 }
73
74 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
75 let elements: Vec<Tag> = v.iter().map(|&b| Tag::new_u8(b)).collect();
76 Ok(Tag::new_array(TagKind::U8, elements))
77 }
78
79 fn serialize_none(self) -> Result<Self::Ok> {
80 Ok(Tag::new_option(TagKind::String, None))
81 }
82
83 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
84 where
85 T: ?Sized + Serialize,
86 {
87 let inner_tag = value.serialize(&mut TagSerializer)?;
88 let kind = inner_tag.kind();
89 Ok(Tag::new_option(kind, Some(inner_tag)))
90 }
91
92 fn serialize_unit(self) -> Result<Self::Ok> {
93 Ok(Tag::new_list(vec![]))
94 }
95
96 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
97 self.serialize_unit()
98 }
99
100 fn serialize_unit_variant(
101 self,
102 _name: &'static str,
103 _variant_index: u32,
104 variant: &'static str,
105 ) -> Result<Self::Ok> {
106 Ok(Tag::new_string(variant))
107 }
108
109 fn serialize_newtype_struct<T>(
110 self,
111 _name: &'static str,
112 value: &T,
113 ) -> Result<Self::Ok>
114 where
115 T: ?Sized + Serialize,
116 {
117 value.serialize(self)
118 }
119
120 fn serialize_newtype_variant<T>(
121 self,
122 _name: &'static str,
123 _variant_index: u32,
124 variant: &'static str,
125 value: &T,
126 ) -> Result<Self::Ok>
127 where
128 T: ?Sized + Serialize,
129 {
130 let key = Tag::new_string(variant);
131 let value = value.serialize(&mut TagSerializer)?;
132 Ok(Tag::new_map(vec![(key, value)]))
133 }
134
135 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
136 Ok(helper::SerializeVec::new())
137 }
138
139 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
140 self.serialize_seq(Some(len))
141 }
142
143 fn serialize_tuple_struct(
144 self,
145 _name: &'static str,
146 len: usize,
147 ) -> Result<Self::SerializeTupleStruct> {
148 self.serialize_seq(Some(len))
149 }
150
151 fn serialize_tuple_variant(
152 self,
153 _name: &'static str,
154 _variant_index: u32,
155 variant: &'static str,
156 _len: usize,
157 ) -> Result<Self::SerializeTupleVariant> {
158 Ok(helper::SerializeTupleVariant::new(variant))
159 }
160
161 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
162 Ok(helper::SerializeMap::new())
163 }
164
165 fn serialize_struct(
166 self,
167 _name: &'static str,
168 len: usize,
169 ) -> Result<Self::SerializeStruct> {
170 self.serialize_map(Some(len))
171 }
172
173 fn serialize_struct_variant(
174 self,
175 _name: &'static str,
176 _variant_index: u32,
177 variant: &'static str,
178 _len: usize,
179 ) -> Result<Self::SerializeStructVariant> {
180 Ok(helper::SerializeStructVariant::new(variant))
181 }
182}