aldrin_core/
generic_value.rs

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

aldrin_core/
generic_value.rs
