1#[cfg(feature = "introspection")]
2use crate::introspection::{ir, Introspectable, LexicalId, References};
3use crate::tags::{self, PrimaryTag, Tag};
4use crate::{
5 Bytes, ChannelCookie, Deserialize, DeserializeError, Deserializer, ObjectId, Serialize,
6 SerializeError, Serializer, ServiceId, ValueKind,
7};
8use std::collections::{HashMap, HashSet};
9use uuid::Uuid;
10
11#[derive(Debug, Clone, PartialEq)]
12#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
13#[cfg_attr(
14 feature = "serde",
15 derive(serde::Serialize, serde::Deserialize),
16 serde(rename_all = "kebab-case")
17)]
18pub enum Value {
19 None,
20 Some(Box<Self>),
21 Bool(bool),
22 U8(u8),
23 I8(i8),
24 U16(u16),
25 I16(i16),
26 U32(u32),
27 I32(i32),
28 U64(u64),
29 I64(i64),
30 F32(f32),
31 F64(f64),
32 String(String),
33 Uuid(Uuid),
34 ObjectId(ObjectId),
35 ServiceId(ServiceId),
36 Vec(Vec<Self>),
37 Bytes(Bytes),
38 U8Map(HashMap<u8, Self>),
39 I8Map(HashMap<i8, Self>),
40 U16Map(HashMap<u16, Self>),
41 I16Map(HashMap<i16, Self>),
42 U32Map(HashMap<u32, Self>),
43 I32Map(HashMap<i32, Self>),
44 U64Map(HashMap<u64, Self>),
45 I64Map(HashMap<i64, Self>),
46 StringMap(HashMap<String, Self>),
47 UuidMap(HashMap<Uuid, Self>),
48 U8Set(HashSet<u8>),
49 I8Set(HashSet<i8>),
50 U16Set(HashSet<u16>),
51 I16Set(HashSet<i16>),
52 U32Set(HashSet<u32>),
53 I32Set(HashSet<i32>),
54 U64Set(HashSet<u64>),
55 I64Set(HashSet<i64>),
56 StringSet(HashSet<String>),
57 UuidSet(HashSet<Uuid>),
58 Struct(Struct),
59 Enum(Box<Enum>),
60 Sender(ChannelCookie),
61 Receiver(ChannelCookie),
62}
63
64impl Value {
65 pub fn is_none(&self) -> bool {
66 matches!(self, Self::None)
67 }
68}
69
70impl PrimaryTag for Value {
71 type Tag = tags::Value;
72}
73
74impl Serialize<tags::Value> for Value {
75 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
76 serializer.serialize(&self)
77 }
78}
79
80impl Serialize<tags::Value> for &Value {
81 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
82 match self {
83 Value::None => serializer.serialize_none(),
84 Value::Some(value) => serializer.serialize_some(value),
85 Value::Bool(value) => serializer.serialize_bool(*value),
86 Value::U8(value) => serializer.serialize_u8(*value),
87 Value::I8(value) => serializer.serialize_i8(*value),
88 Value::U16(value) => serializer.serialize_u16(*value),
89 Value::I16(value) => serializer.serialize_i16(*value),
90 Value::U32(value) => serializer.serialize_u32(*value),
91 Value::I32(value) => serializer.serialize_i32(*value),
92 Value::U64(value) => serializer.serialize_u64(*value),
93 Value::I64(value) => serializer.serialize_i64(*value),
94 Value::F32(value) => serializer.serialize_f32(*value),
95 Value::F64(value) => serializer.serialize_f64(*value),
96 Value::String(value) => serializer.serialize_string(value),
97 Value::Uuid(value) => serializer.serialize_uuid(*value),
98 Value::ObjectId(value) => serializer.serialize_object_id(*value),
99 Value::ServiceId(value) => serializer.serialize_service_id(*value),
100 Value::Vec(value) => serializer.serialize_vec2_iter(value),
101 Value::Bytes(value) => serializer.serialize_byte_slice2(value),
102 Value::U8Map(value) => serializer.serialize_map2_iter::<tags::U8, _, _, _, _>(value),
103 Value::I8Map(value) => serializer.serialize_map2_iter::<tags::I8, _, _, _, _>(value),
104 Value::U16Map(value) => serializer.serialize_map2_iter::<tags::U16, _, _, _, _>(value),
105 Value::I16Map(value) => serializer.serialize_map2_iter::<tags::I16, _, _, _, _>(value),
106 Value::U32Map(value) => serializer.serialize_map2_iter::<tags::U32, _, _, _, _>(value),
107 Value::I32Map(value) => serializer.serialize_map2_iter::<tags::I32, _, _, _, _>(value),
108 Value::U64Map(value) => serializer.serialize_map2_iter::<tags::U64, _, _, _, _>(value),
109 Value::I64Map(value) => serializer.serialize_map2_iter::<tags::I64, _, _, _, _>(value),
110
111 Value::StringMap(value) => {
112 serializer.serialize_map2_iter::<tags::String, _, _, _, _>(value)
113 }
114
115 Value::UuidMap(value) => {
116 serializer.serialize_map2_iter::<tags::Uuid, _, _, _, _>(value)
117 }
118
119 Value::U8Set(value) => serializer.serialize_set2_iter::<tags::U8, _>(value),
120 Value::I8Set(value) => serializer.serialize_set2_iter::<tags::I8, _>(value),
121 Value::U16Set(value) => serializer.serialize_set2_iter::<tags::U16, _>(value),
122 Value::I16Set(value) => serializer.serialize_set2_iter::<tags::I16, _>(value),
123 Value::U32Set(value) => serializer.serialize_set2_iter::<tags::U32, _>(value),
124 Value::I32Set(value) => serializer.serialize_set2_iter::<tags::I32, _>(value),
125 Value::U64Set(value) => serializer.serialize_set2_iter::<tags::U64, _>(value),
126 Value::I64Set(value) => serializer.serialize_set2_iter::<tags::I64, _>(value),
127 Value::StringSet(value) => serializer.serialize_set2_iter::<tags::String, _>(value),
128 Value::UuidSet(value) => serializer.serialize_set2_iter::<tags::Uuid, _>(value),
129 Value::Struct(value) => serializer.serialize(value),
130 Value::Enum(value) => serializer.serialize(value),
131 Value::Sender(value) => serializer.serialize_sender(*value),
132 Value::Receiver(value) => serializer.serialize_receiver(*value),
133 }
134 }
135}
136
137impl Deserialize<tags::Value> for Value {
138 fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
139 match deserializer.peek_value_kind()? {
140 ValueKind::None => deserializer.deserialize_none().map(|()| Self::None),
141 ValueKind::Some => deserializer.deserialize_some().map(Self::Some),
142 ValueKind::Bool => deserializer.deserialize_bool().map(Self::Bool),
143 ValueKind::U8 => deserializer.deserialize_u8().map(Self::U8),
144 ValueKind::I8 => deserializer.deserialize_i8().map(Self::I8),
145 ValueKind::U16 => deserializer.deserialize_u16().map(Self::U16),
146 ValueKind::I16 => deserializer.deserialize_i16().map(Self::I16),
147 ValueKind::U32 => deserializer.deserialize_u32().map(Self::U32),
148 ValueKind::I32 => deserializer.deserialize_i32().map(Self::I32),
149 ValueKind::U64 => deserializer.deserialize_u64().map(Self::U64),
150 ValueKind::I64 => deserializer.deserialize_i64().map(Self::I64),
151 ValueKind::F32 => deserializer.deserialize_f32().map(Self::F32),
152 ValueKind::F64 => deserializer.deserialize_f64().map(Self::F64),
153 ValueKind::String => deserializer.deserialize_string().map(Self::String),
154 ValueKind::Uuid => deserializer.deserialize_uuid().map(Self::Uuid),
155 ValueKind::ObjectId => deserializer.deserialize_object_id().map(Self::ObjectId),
156 ValueKind::ServiceId => deserializer.deserialize_service_id().map(Self::ServiceId),
157 ValueKind::Vec1 => deserializer.deserialize_vec1_extend_new().map(Self::Vec),
158
159 ValueKind::Bytes1 => deserializer
160 .deserialize_bytes1_extend_new()
161 .map(Bytes)
162 .map(Self::Bytes),
163
164 ValueKind::U8Map1 => deserializer
165 .deserialize_map1_extend_new::<tags::U8, _, _, _, _>()
166 .map(Self::U8Map),
167
168 ValueKind::I8Map1 => deserializer
169 .deserialize_map1_extend_new::<tags::I8, _, _, _, _>()
170 .map(Self::I8Map),
171
172 ValueKind::U16Map1 => deserializer
173 .deserialize_map1_extend_new::<tags::U16, _, _, _, _>()
174 .map(Self::U16Map),
175
176 ValueKind::I16Map1 => deserializer
177 .deserialize_map1_extend_new::<tags::I16, _, _, _, _>()
178 .map(Self::I16Map),
179
180 ValueKind::U32Map1 => deserializer
181 .deserialize_map1_extend_new::<tags::U32, _, _, _, _>()
182 .map(Self::U32Map),
183
184 ValueKind::I32Map1 => deserializer
185 .deserialize_map1_extend_new::<tags::I32, _, _, _, _>()
186 .map(Self::I32Map),
187
188 ValueKind::U64Map1 => deserializer
189 .deserialize_map1_extend_new::<tags::U64, _, _, _, _>()
190 .map(Self::U64Map),
191
192 ValueKind::I64Map1 => deserializer
193 .deserialize_map1_extend_new::<tags::I64, _, _, _, _>()
194 .map(Self::I64Map),
195
196 ValueKind::StringMap1 => deserializer
197 .deserialize_map1_extend_new::<tags::String, _, _, _, _>()
198 .map(Self::StringMap),
199
200 ValueKind::UuidMap1 => deserializer
201 .deserialize_map1_extend_new::<tags::Uuid, _, _, _, _>()
202 .map(Self::UuidMap),
203
204 ValueKind::U8Set1 => deserializer
205 .deserialize_set1_extend_new::<tags::U8, u8, _>()
206 .map(Self::U8Set),
207
208 ValueKind::I8Set1 => deserializer
209 .deserialize_set1_extend_new::<tags::I8, i8, _>()
210 .map(Self::I8Set),
211
212 ValueKind::U16Set1 => deserializer
213 .deserialize_set1_extend_new::<tags::U16, u16, _>()
214 .map(Self::U16Set),
215
216 ValueKind::I16Set1 => deserializer
217 .deserialize_set1_extend_new::<tags::I16, i16, _>()
218 .map(Self::I16Set),
219
220 ValueKind::U32Set1 => deserializer
221 .deserialize_set1_extend_new::<tags::U32, u32, _>()
222 .map(Self::U32Set),
223
224 ValueKind::I32Set1 => deserializer
225 .deserialize_set1_extend_new::<tags::I32, i32, _>()
226 .map(Self::I32Set),
227
228 ValueKind::U64Set1 => deserializer
229 .deserialize_set1_extend_new::<tags::U64, u64, _>()
230 .map(Self::U64Set),
231
232 ValueKind::I64Set1 => deserializer
233 .deserialize_set1_extend_new::<tags::I64, i64, _>()
234 .map(Self::I64Set),
235
236 ValueKind::StringSet1 => deserializer
237 .deserialize_set1_extend_new::<tags::String, _, _>()
238 .map(Self::StringSet),
239
240 ValueKind::UuidSet1 => deserializer
241 .deserialize_set1_extend_new::<tags::Uuid, Uuid, _>()
242 .map(Self::UuidSet),
243
244 ValueKind::Struct1 | ValueKind::Struct2 => deserializer.deserialize().map(Self::Struct),
245 ValueKind::Enum => deserializer.deserialize().map(Self::Enum),
246 ValueKind::Sender => deserializer.deserialize_sender().map(Self::Sender),
247 ValueKind::Receiver => deserializer.deserialize_receiver().map(Self::Receiver),
248 ValueKind::Vec2 => deserializer.deserialize_vec2_extend_new().map(Self::Vec),
249
250 ValueKind::Bytes2 => deserializer
251 .deserialize_bytes2_extend_new()
252 .map(Bytes)
253 .map(Self::Bytes),
254
255 ValueKind::U8Map2 => deserializer
256 .deserialize_map2_extend_new::<tags::U8, _, _, _, _>()
257 .map(Self::U8Map),
258
259 ValueKind::I8Map2 => deserializer
260 .deserialize_map2_extend_new::<tags::I8, _, _, _, _>()
261 .map(Self::I8Map),
262
263 ValueKind::U16Map2 => deserializer
264 .deserialize_map2_extend_new::<tags::U16, _, _, _, _>()
265 .map(Self::U16Map),
266
267 ValueKind::I16Map2 => deserializer
268 .deserialize_map2_extend_new::<tags::I16, _, _, _, _>()
269 .map(Self::I16Map),
270
271 ValueKind::U32Map2 => deserializer
272 .deserialize_map2_extend_new::<tags::U32, _, _, _, _>()
273 .map(Self::U32Map),
274
275 ValueKind::I32Map2 => deserializer
276 .deserialize_map2_extend_new::<tags::I32, _, _, _, _>()
277 .map(Self::I32Map),
278
279 ValueKind::U64Map2 => deserializer
280 .deserialize_map2_extend_new::<tags::U64, _, _, _, _>()
281 .map(Self::U64Map),
282
283 ValueKind::I64Map2 => deserializer
284 .deserialize_map2_extend_new::<tags::I64, _, _, _, _>()
285 .map(Self::I64Map),
286
287 ValueKind::StringMap2 => deserializer
288 .deserialize_map2_extend_new::<tags::String, _, _, _, _>()
289 .map(Self::StringMap),
290
291 ValueKind::UuidMap2 => deserializer
292 .deserialize_map2_extend_new::<tags::Uuid, _, _, _, _>()
293 .map(Self::UuidMap),
294
295 ValueKind::U8Set2 => deserializer
296 .deserialize_set2_extend_new::<tags::U8, u8, _>()
297 .map(Self::U8Set),
298
299 ValueKind::I8Set2 => deserializer
300 .deserialize_set2_extend_new::<tags::I8, i8, _>()
301 .map(Self::I8Set),
302
303 ValueKind::U16Set2 => deserializer
304 .deserialize_set2_extend_new::<tags::U16, u16, _>()
305 .map(Self::U16Set),
306
307 ValueKind::I16Set2 => deserializer
308 .deserialize_set2_extend_new::<tags::I16, i16, _>()
309 .map(Self::I16Set),
310
311 ValueKind::U32Set2 => deserializer
312 .deserialize_set2_extend_new::<tags::U32, u32, _>()
313 .map(Self::U32Set),
314
315 ValueKind::I32Set2 => deserializer
316 .deserialize_set2_extend_new::<tags::I32, i32, _>()
317 .map(Self::I32Set),
318
319 ValueKind::U64Set2 => deserializer
320 .deserialize_set2_extend_new::<tags::U64, u64, _>()
321 .map(Self::U64Set),
322
323 ValueKind::I64Set2 => deserializer
324 .deserialize_set2_extend_new::<tags::I64, i64, _>()
325 .map(Self::I64Set),
326
327 ValueKind::StringSet2 => deserializer
328 .deserialize_set2_extend_new::<tags::String, _, _>()
329 .map(Self::StringSet),
330
331 ValueKind::UuidSet2 => deserializer
332 .deserialize_set2_extend_new::<tags::Uuid, Uuid, _>()
333 .map(Self::UuidSet),
334 }
335 }
336}
337
338#[cfg(feature = "introspection")]
339impl Introspectable for Value {
340 fn layout() -> ir::LayoutIr {
341 ir::BuiltInTypeIr::Value.into()
342 }
343
344 fn lexical_id() -> LexicalId {
345 LexicalId::VALUE
346 }
347
348 fn add_references(_references: &mut References) {}
349}
350
351#[derive(Debug, Clone, PartialEq)]
352#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
353#[cfg_attr(
354 feature = "serde",
355 derive(serde::Serialize, serde::Deserialize),
356 serde(transparent)
357)]
358pub struct Struct(pub HashMap<u32, Value>);
359
360impl Tag for Struct {}
361
362impl PrimaryTag for Struct {
363 type Tag = Self;
364}
365
366impl Serialize<Self> for Struct {
367 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
368 serializer.serialize(&self)
369 }
370}
371
372impl Serialize<Struct> for &Struct {
373 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
374 let mut serializer = serializer.serialize_struct2()?;
375
376 for (&id, field) in &self.0 {
377 serializer.serialize(id, field)?;
378 }
379
380 serializer.finish()
381 }
382}
383
384impl Deserialize<Self> for Struct {
385 fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
386 let mut deserializer = deserializer.deserialize_struct()?;
387 let mut value = HashMap::new();
388
389 while let Some(deserializer) = deserializer.deserialize()? {
390 let id = deserializer.id();
391 let field = deserializer.deserialize()?;
392
393 value.insert(id, field);
394 }
395
396 deserializer.finish(Self(value))
397 }
398}
399
400#[derive(Debug, Clone, PartialEq)]
401#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
402#[cfg_attr(
403 feature = "serde",
404 derive(serde::Serialize, serde::Deserialize),
405 serde(rename_all = "kebab-case")
406)]
407pub struct Enum {
408 pub id: u32,
409 pub value: Value,
410}
411
412impl Enum {
413 pub fn new(id: u32, value: Value) -> Self {
414 Self { id, value }
415 }
416}
417
418impl Tag for Enum {}
419
420impl PrimaryTag for Enum {
421 type Tag = Self;
422}
423
424impl Serialize<Self> for Enum {
425 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
426 serializer.serialize(&self)
427 }
428}
429
430impl Deserialize<Self> for Enum {
431 fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
432 let deserializer = deserializer.deserialize_enum()?;
433
434 let id = deserializer.id();
435 let value = deserializer.deserialize()?;
436
437 Ok(Self::new(id, value))
438 }
439}
440
441impl Serialize<Enum> for &Enum {
442 fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
443 serializer.serialize_enum(self.id, &self.value)
444 }
445}