aldrin_core/
generic_value.rs

1use crate::error::{DeserializeError, SerializeError};
2use crate::ids::{ChannelCookie, ObjectId, ServiceId};
3use crate::value::ValueKind;
4use crate::value_deserializer::{Deserialize, Deserializer};
5use crate::value_serializer::{Serialize, Serializer};
6use std::collections::{HashMap, HashSet};
7use uuid::Uuid;
8
9// Tests are in crate::value::test;
10
11#[derive(Debug, Clone, PartialEq)]
12#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
13pub enum Value {
14    None,
15    Some(Box<Value>),
16    Bool(bool),
17    U8(u8),
18    I8(i8),
19    U16(u16),
20    I16(i16),
21    U32(u32),
22    I32(i32),
23    U64(u64),
24    I64(i64),
25    F32(f32),
26    F64(f64),
27    String(String),
28    Uuid(Uuid),
29    ObjectId(ObjectId),
30    ServiceId(ServiceId),
31    Vec(Vec<Value>),
32    Bytes(Vec<u8>),
33    U8Map(HashMap<u8, Value>),
34    I8Map(HashMap<i8, Value>),
35    U16Map(HashMap<u16, Value>),
36    I16Map(HashMap<i16, Value>),
37    U32Map(HashMap<u32, Value>),
38    I32Map(HashMap<i32, Value>),
39    U64Map(HashMap<u64, Value>),
40    I64Map(HashMap<i64, Value>),
41    StringMap(HashMap<String, Value>),
42    UuidMap(HashMap<Uuid, Value>),
43    U8Set(HashSet<u8>),
44    I8Set(HashSet<i8>),
45    U16Set(HashSet<u16>),
46    I16Set(HashSet<i16>),
47    U32Set(HashSet<u32>),
48    I32Set(HashSet<i32>),
49    U64Set(HashSet<u64>),
50    I64Set(HashSet<i64>),
51    StringSet(HashSet<String>),
52    UuidSet(HashSet<Uuid>),
53    Struct(Struct),
54    Enum(Box<Enum>),
55    Sender(ChannelCookie),
56    Receiver(ChannelCookie),
57}
58
59impl Value {
60    pub fn is_none(&self) -> bool {
61        matches!(self, Self::None)
62    }
63
64    pub fn kind(&self) -> ValueKind {
65        match self {
66            Self::None => ValueKind::None,
67            Self::Some(_) => ValueKind::Some,
68            Self::Bool(_) => ValueKind::Bool,
69            Self::U8(_) => ValueKind::U8,
70            Self::I8(_) => ValueKind::I8,
71            Self::U16(_) => ValueKind::U16,
72            Self::I16(_) => ValueKind::I16,
73            Self::U32(_) => ValueKind::U32,
74            Self::I32(_) => ValueKind::I32,
75            Self::U64(_) => ValueKind::U64,
76            Self::I64(_) => ValueKind::I64,
77            Self::F32(_) => ValueKind::F32,
78            Self::F64(_) => ValueKind::F64,
79            Self::String(_) => ValueKind::String,
80            Self::Uuid(_) => ValueKind::Uuid,
81            Self::ObjectId(_) => ValueKind::ObjectId,
82            Self::ServiceId(_) => ValueKind::ServiceId,
83            Self::Vec(_) => ValueKind::Vec,
84            Self::Bytes(_) => ValueKind::Bytes,
85            Self::U8Map(_) => ValueKind::U8Map,
86            Self::I8Map(_) => ValueKind::I8Map,
87            Self::U16Map(_) => ValueKind::U16Map,
88            Self::I16Map(_) => ValueKind::I16Map,
89            Self::U32Map(_) => ValueKind::U32Map,
90            Self::I32Map(_) => ValueKind::I32Map,
91            Self::U64Map(_) => ValueKind::U64Map,
92            Self::I64Map(_) => ValueKind::I64Map,
93            Self::StringMap(_) => ValueKind::StringMap,
94            Self::UuidMap(_) => ValueKind::UuidMap,
95            Self::U8Set(_) => ValueKind::U8Set,
96            Self::I8Set(_) => ValueKind::I8Set,
97            Self::U16Set(_) => ValueKind::U16Set,
98            Self::I16Set(_) => ValueKind::I16Set,
99            Self::U32Set(_) => ValueKind::U32Set,
100            Self::I32Set(_) => ValueKind::I32Set,
101            Self::U64Set(_) => ValueKind::U64Set,
102            Self::I64Set(_) => ValueKind::I64Set,
103            Self::StringSet(_) => ValueKind::StringSet,
104            Self::UuidSet(_) => ValueKind::UuidSet,
105            Self::Struct(_) => ValueKind::Struct,
106            Self::Enum(_) => ValueKind::Enum,
107            Self::Sender(_) => ValueKind::Sender,
108            Self::Receiver(_) => ValueKind::Receiver,
109        }
110    }
111}
112
113impl Serialize for Value {
114    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
115        match self {
116            Self::None => serializer.serialize_none(),
117            Self::Some(value) => serializer.serialize_some(value)?,
118            Self::Bool(value) => serializer.serialize_bool(*value),
119            Self::U8(value) => serializer.serialize_u8(*value),
120            Self::I8(value) => serializer.serialize_i8(*value),
121            Self::U16(value) => serializer.serialize_u16(*value),
122            Self::I16(value) => serializer.serialize_i16(*value),
123            Self::U32(value) => serializer.serialize_u32(*value),
124            Self::I32(value) => serializer.serialize_i32(*value),
125            Self::U64(value) => serializer.serialize_u64(*value),
126            Self::I64(value) => serializer.serialize_i64(*value),
127            Self::F32(value) => serializer.serialize_f32(*value),
128            Self::F64(value) => serializer.serialize_f64(*value),
129            Self::String(value) => serializer.serialize_string(value)?,
130            Self::Uuid(value) => serializer.serialize_uuid(*value),
131            Self::ObjectId(value) => serializer.serialize_object_id(*value),
132            Self::ServiceId(value) => serializer.serialize_service_id(*value),
133            Self::Vec(value) => serializer.serialize_vec_iter(value)?,
134            Self::Bytes(value) => serializer.serialize_byte_slice(value)?,
135            Self::U8Map(value) => serializer.serialize_map_iter(value)?,
136            Self::I8Map(value) => serializer.serialize_map_iter(value)?,
137            Self::U16Map(value) => serializer.serialize_map_iter(value)?,
138            Self::I16Map(value) => serializer.serialize_map_iter(value)?,
139            Self::U32Map(value) => serializer.serialize_map_iter(value)?,
140            Self::I32Map(value) => serializer.serialize_map_iter(value)?,
141            Self::U64Map(value) => serializer.serialize_map_iter(value)?,
142            Self::I64Map(value) => serializer.serialize_map_iter(value)?,
143            Self::StringMap(value) => serializer.serialize_map_iter(value)?,
144            Self::UuidMap(value) => serializer.serialize_map_iter(value)?,
145            Self::U8Set(value) => serializer.serialize_set_iter(value)?,
146            Self::I8Set(value) => serializer.serialize_set_iter(value)?,
147            Self::U16Set(value) => serializer.serialize_set_iter(value)?,
148            Self::I16Set(value) => serializer.serialize_set_iter(value)?,
149            Self::U32Set(value) => serializer.serialize_set_iter(value)?,
150            Self::I32Set(value) => serializer.serialize_set_iter(value)?,
151            Self::U64Set(value) => serializer.serialize_set_iter(value)?,
152            Self::I64Set(value) => serializer.serialize_set_iter(value)?,
153            Self::StringSet(value) => serializer.serialize_set_iter(value)?,
154            Self::UuidSet(value) => serializer.serialize_set_iter(value)?,
155            Self::Struct(value) => value.serialize(serializer)?,
156            Self::Enum(value) => value.serialize(serializer)?,
157            Self::Sender(value) => serializer.serialize_sender(*value),
158            Self::Receiver(value) => serializer.serialize_receiver(*value),
159        }
160
161        Ok(())
162    }
163}
164
165impl Deserialize for Value {
166    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
167        match deserializer.peek_value_kind()? {
168            ValueKind::None => deserializer.deserialize_none().map(|_| Self::None),
169            ValueKind::Some => deserializer.deserialize_some().map(Self::Some),
170            ValueKind::Bool => deserializer.deserialize_bool().map(Self::Bool),
171            ValueKind::U8 => deserializer.deserialize_u8().map(Self::U8),
172            ValueKind::I8 => deserializer.deserialize_i8().map(Self::I8),
173            ValueKind::U16 => deserializer.deserialize_u16().map(Self::U16),
174            ValueKind::I16 => deserializer.deserialize_i16().map(Self::I16),
175            ValueKind::U32 => deserializer.deserialize_u32().map(Self::U32),
176            ValueKind::I32 => deserializer.deserialize_i32().map(Self::I32),
177            ValueKind::U64 => deserializer.deserialize_u64().map(Self::U64),
178            ValueKind::I64 => deserializer.deserialize_i64().map(Self::I64),
179            ValueKind::F32 => deserializer.deserialize_f32().map(Self::F32),
180            ValueKind::F64 => deserializer.deserialize_f64().map(Self::F64),
181            ValueKind::String => deserializer.deserialize_string().map(Self::String),
182            ValueKind::Uuid => deserializer.deserialize_uuid().map(Self::Uuid),
183            ValueKind::ObjectId => deserializer.deserialize_object_id().map(Self::ObjectId),
184            ValueKind::ServiceId => deserializer.deserialize_service_id().map(Self::ServiceId),
185            ValueKind::Vec => deserializer.deserialize_vec_extend_new().map(Self::Vec),
186            ValueKind::Bytes => deserializer.deserialize_bytes_to_vec().map(Self::Bytes),
187            ValueKind::U8Map => deserializer.deserialize_map_extend_new().map(Self::U8Map),
188            ValueKind::I8Map => deserializer.deserialize_map_extend_new().map(Self::I8Map),
189            ValueKind::U16Map => deserializer.deserialize_map_extend_new().map(Self::U16Map),
190            ValueKind::I16Map => deserializer.deserialize_map_extend_new().map(Self::I16Map),
191            ValueKind::U32Map => deserializer.deserialize_map_extend_new().map(Self::U32Map),
192            ValueKind::I32Map => deserializer.deserialize_map_extend_new().map(Self::I32Map),
193            ValueKind::U64Map => deserializer.deserialize_map_extend_new().map(Self::U64Map),
194            ValueKind::I64Map => deserializer.deserialize_map_extend_new().map(Self::I64Map),
195            ValueKind::StringMap => deserializer
196                .deserialize_map_extend_new()
197                .map(Self::StringMap),
198            ValueKind::UuidMap => deserializer.deserialize_map_extend_new().map(Self::UuidMap),
199            ValueKind::U8Set => deserializer
200                .deserialize_set_extend_new::<u8, _>()
201                .map(Self::U8Set),
202            ValueKind::I8Set => deserializer
203                .deserialize_set_extend_new::<i8, _>()
204                .map(Self::I8Set),
205            ValueKind::U16Set => deserializer
206                .deserialize_set_extend_new::<u16, _>()
207                .map(Self::U16Set),
208            ValueKind::I16Set => deserializer
209                .deserialize_set_extend_new::<i16, _>()
210                .map(Self::I16Set),
211            ValueKind::U32Set => deserializer
212                .deserialize_set_extend_new::<u32, _>()
213                .map(Self::U32Set),
214            ValueKind::I32Set => deserializer
215                .deserialize_set_extend_new::<i32, _>()
216                .map(Self::I32Set),
217            ValueKind::U64Set => deserializer
218                .deserialize_set_extend_new::<u64, _>()
219                .map(Self::U64Set),
220            ValueKind::I64Set => deserializer
221                .deserialize_set_extend_new::<i64, _>()
222                .map(Self::I64Set),
223            ValueKind::StringSet => deserializer
224                .deserialize_set_extend_new()
225                .map(Self::StringSet),
226            ValueKind::UuidSet => deserializer
227                .deserialize_set_extend_new::<Uuid, _>()
228                .map(Self::UuidSet),
229            ValueKind::Struct => Struct::deserialize(deserializer).map(Self::Struct),
230            ValueKind::Enum => Enum::deserialize(deserializer)
231                .map(Box::new)
232                .map(Self::Enum),
233            ValueKind::Sender => deserializer.deserialize_sender().map(Self::Sender),
234            ValueKind::Receiver => deserializer.deserialize_receiver().map(Self::Receiver),
235        }
236    }
237}
238
239#[derive(Debug, Clone, PartialEq)]
240#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
241pub struct Struct(pub HashMap<u32, Value>);
242
243impl Serialize for Struct {
244    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
245        let mut serializer = serializer.serialize_struct(self.0.len())?;
246
247        for (&id, field) in &self.0 {
248            serializer.serialize_field(id, field)?;
249        }
250
251        serializer.finish()
252    }
253}
254
255impl Deserialize for Struct {
256    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
257        let mut deserializer = deserializer.deserialize_struct()?;
258
259        let mut value = HashMap::new();
260        while deserializer.has_more_fields() {
261            let deserializer = deserializer.deserialize_field()?;
262            let id = deserializer.id();
263            let field = deserializer.deserialize()?;
264            value.insert(id, field);
265        }
266
267        Ok(Self(value))
268    }
269}
270
271#[derive(Debug, Clone, PartialEq)]
272#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
273pub struct Enum {
274    pub variant: u32,
275    pub value: Value,
276}
277
278impl Enum {
279    pub fn new(variant: u32, value: Value) -> Self {
280        Self { variant, value }
281    }
282}
283
284impl Serialize for Enum {
285    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
286        serializer.serialize_enum(self.variant, &self.value)
287    }
288}
289
290impl Deserialize for Enum {
291    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
292        let deserializer = deserializer.deserialize_enum()?;
293        let variant = deserializer.variant();
294        let value = deserializer.deserialize()?;
295        Ok(Self::new(variant, value))
296    }
297}
aldrin_core/generic_value.rs

aldrin_core/
generic_value.rs
