messagepack_serde/value/
value_owned.rs

1use super::number::Number;
2use super::value_ref::ValueRef;
3use alloc::string::{String, ToString};
4use alloc::vec::Vec;
5use messagepack_core::extension::ExtensionRef;
6use serde::{de::Visitor, ser::SerializeMap};
7
8/// Owned representation of any MessagePack value.
9#[derive(Debug, Clone, PartialEq, PartialOrd)]
10pub enum Value {
11    /// Represents nil format.
12    Nil,
13    /// Represents bool format family.
14    Bool(bool),
15    /// Represents `bin 8`, `bin 16` and `bin 32`.
16    Bin(Vec<u8>),
17    /// Represents ext format family as owned bytes.
18    Extension {
19        /// Application-defined extension type code.
20        r#type: i8,
21        /// Owned payload bytes.
22        data: Vec<u8>,
23    },
24    /// Represents int format family and float format family.
25    Number(Number),
26    /// Represents str format family.
27    String(String),
28    /// Represents array format family.
29    Array(Vec<Value>),
30    /// Represents map format family.
31    Map(Vec<(Value, Value)>),
32}
33
34impl Value {
35    /// Returns true if the `Value` is nil.
36    pub fn is_nil(&self) -> bool {
37        matches!(self, Value::Nil)
38    }
39
40    /// If the `Value` is boolean, returns contained value.
41    pub fn as_bool(&self) -> Option<bool> {
42        match self {
43            Value::Bool(v) => Some(*v),
44            _ => None,
45        }
46    }
47
48    /// If the `Value` is bin, returns contained slice.
49    pub fn as_bin(&self) -> Option<&[u8]> {
50        match self {
51            Value::Bin(v) => Some(v.as_slice()),
52            _ => None,
53        }
54    }
55
56    /// If the `Value` is ext, returns `(type, data)` as tuple.
57    pub fn as_extension(&self) -> Option<(i8, &[u8])> {
58        match self {
59            Value::Extension { r#type, data } => Some((*r#type, data.as_slice())),
60            _ => None,
61        }
62    }
63
64    /// If the `Value` is number, returns contained value.
65    pub fn as_number(&self) -> Option<Number> {
66        match self {
67            Value::Number(v) => Some(*v),
68            _ => None,
69        }
70    }
71
72    /// If the `Value` is str, returns contained slice.
73    pub fn as_string(&self) -> Option<&str> {
74        match self {
75            Value::String(v) => Some(v.as_str()),
76            _ => None,
77        }
78    }
79
80    /// If the `Value` is array, returns contained slice.
81    pub fn as_array(&self) -> Option<&[Value]> {
82        match self {
83            Value::Array(v) => Some(v.as_slice()),
84            _ => None,
85        }
86    }
87
88    /// If the `Value` is map, returns contained slice of pairs.
89    pub fn as_map(&self) -> Option<&[(Value, Value)]> {
90        match self {
91            Value::Map(v) => Some(v.as_slice()),
92            _ => None,
93        }
94    }
95}
96
97impl serde::Serialize for Value {
98    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
99    where
100        S: serde::Serializer,
101    {
102        match self {
103            Value::Nil => serializer.serialize_none(),
104            Value::Bool(v) => serializer.serialize_bool(*v),
105            Value::Bin(b) => serializer.serialize_bytes(b),
106            Value::Extension { r#type, data } => {
107                // Encode using the same newtype layout as `ext_ref`.
108                super::ext_ref::serialize(&ExtensionRef::new(*r#type, data.as_slice()), serializer)
109            }
110            Value::Number(n) => n.serialize(serializer),
111            Value::String(s) => serializer.serialize_str(s),
112            Value::Array(vs) => vs.serialize(serializer),
113            Value::Map(items) => {
114                let mut map = serializer.serialize_map(Some(items.len()))?;
115                for (k, v) in items.iter() {
116                    map.serialize_entry(k, v)?;
117                }
118                map.end()
119            }
120        }
121    }
122}
123
124impl<'de> serde::Deserialize<'de> for Value {
125    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
126    where
127        D: serde::Deserializer<'de>,
128    {
129        struct ValueVisitor;
130        impl<'de> Visitor<'de> for ValueVisitor {
131            type Value = Value;
132            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
133                f.write_str("expect valid messagepack")
134            }
135
136            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
137            where
138                E: serde::de::Error,
139            {
140                Ok(Value::Bool(v))
141            }
142
143            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
144            where
145                E: serde::de::Error,
146            {
147                Ok(Value::from(Number::from(v)))
148            }
149
150            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
151            where
152                E: serde::de::Error,
153            {
154                Ok(Value::from(Number::from(v)))
155            }
156
157            fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
158            where
159                E: serde::de::Error,
160            {
161                Ok(Value::from(Number::from(v)))
162            }
163            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
164            where
165                E: serde::de::Error,
166            {
167                Ok(Value::from(Number::from(v)))
168            }
169
170            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
171            where
172                E: serde::de::Error,
173            {
174                Ok(Value::String(v.to_string()))
175            }
176
177            fn visit_none<E>(self) -> Result<Self::Value, E>
178            where
179                E: serde::de::Error,
180            {
181                Ok(Value::Nil)
182            }
183            fn visit_unit<E>(self) -> Result<Self::Value, E>
184            where
185                E: serde::de::Error,
186            {
187                Ok(Value::Nil)
188            }
189
190            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
191            where
192                E: serde::de::Error,
193            {
194                Ok(Value::Bin(v.to_vec()))
195            }
196
197            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
198            where
199                D: serde::Deserializer<'de>,
200            {
201                let ext = super::ext_ref::deserialize(deserializer)?;
202                Ok(Value::Extension {
203                    r#type: ext.r#type,
204                    data: ext.data.to_vec(),
205                })
206            }
207
208            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
209            where
210                A: serde::de::SeqAccess<'de>,
211            {
212                let mut buf = Vec::new();
213                if let Some(size) = seq.size_hint() {
214                    buf.reserve(size);
215                }
216
217                while let Some(v) = seq.next_element::<Value>()? {
218                    buf.push(v);
219                }
220                Ok(Value::Array(buf))
221            }
222
223            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
224            where
225                A: serde::de::MapAccess<'de>,
226            {
227                let mut buf = Vec::new();
228                if let Some(size) = map.size_hint() {
229                    buf.reserve(size);
230                }
231
232                while let Some(v) = map.next_entry::<Value, Value>()? {
233                    buf.push(v);
234                }
235                Ok(Value::Map(buf))
236            }
237        }
238        deserializer.deserialize_any(ValueVisitor)
239    }
240}
241
242impl From<()> for Value {
243    fn from(_: ()) -> Self {
244        Value::Nil
245    }
246}
247
248impl From<bool> for Value {
249    fn from(v: bool) -> Self {
250        Value::Bool(v)
251    }
252}
253
254impl From<u8> for Value {
255    fn from(v: u8) -> Self {
256        Value::Number(Number::from(v))
257    }
258}
259impl From<u16> for Value {
260    fn from(v: u16) -> Self {
261        Value::Number(Number::from(v))
262    }
263}
264impl From<u32> for Value {
265    fn from(v: u32) -> Self {
266        Value::Number(Number::from(v))
267    }
268}
269impl From<u64> for Value {
270    fn from(v: u64) -> Self {
271        Value::Number(Number::from(v))
272    }
273}
274
275impl From<i8> for Value {
276    fn from(v: i8) -> Self {
277        Value::Number(Number::from(v))
278    }
279}
280impl From<i16> for Value {
281    fn from(v: i16) -> Self {
282        Value::Number(Number::from(v))
283    }
284}
285impl From<i32> for Value {
286    fn from(v: i32) -> Self {
287        Value::Number(Number::from(v))
288    }
289}
290impl From<i64> for Value {
291    fn from(v: i64) -> Self {
292        Value::Number(Number::from(v))
293    }
294}
295
296impl From<f32> for Value {
297    fn from(v: f32) -> Self {
298        Value::Number(Number::Float(v.into()))
299    }
300}
301impl From<f64> for Value {
302    fn from(v: f64) -> Self {
303        Value::Number(Number::Float(v))
304    }
305}
306
307impl From<Number> for Value {
308    fn from(v: Number) -> Self {
309        Value::Number(v)
310    }
311}
312
313impl TryFrom<usize> for Value {
314    type Error = core::num::TryFromIntError;
315    fn try_from(value: usize) -> Result<Self, Self::Error> {
316        Number::try_from(value).map(Self::from)
317    }
318}
319
320impl TryFrom<isize> for Value {
321    type Error = core::num::TryFromIntError;
322    fn try_from(value: isize) -> Result<Self, Self::Error> {
323        Number::try_from(value).map(Self::from)
324    }
325}
326
327impl From<&str> for Value {
328    fn from(v: &str) -> Self {
329        Value::String(v.to_string())
330    }
331}
332impl From<String> for Value {
333    fn from(v: String) -> Self {
334        Value::String(v)
335    }
336}
337impl From<&[u8]> for Value {
338    fn from(v: &[u8]) -> Self {
339        Value::Bin(v.to_vec())
340    }
341}
342impl From<Vec<u8>> for Value {
343    fn from(v: Vec<u8>) -> Self {
344        Value::Bin(v)
345    }
346}
347
348impl From<ValueRef<'_>> for Value {
349    fn from(v: ValueRef<'_>) -> Self {
350        match v {
351            ValueRef::Nil => Value::Nil,
352            ValueRef::Bool(b) => Value::Bool(b),
353            ValueRef::Bin(b) => Value::Bin(b.to_vec()),
354            ValueRef::Extension(ext) => Value::Extension {
355                r#type: ext.r#type,
356                data: ext.data.to_vec(),
357            },
358            ValueRef::Number(n) => Value::Number(n),
359            ValueRef::String(s) => Value::String(s.to_string()),
360            ValueRef::Array(items) => Value::Array(items.into_iter().map(Value::from).collect()),
361            ValueRef::Map(items) => Value::Map(
362                items
363                    .into_iter()
364                    .map(|(k, v)| (Value::from(k), Value::from(v)))
365                    .collect(),
366            ),
367        }
368    }
369}
370
371#[cfg(test)]
372mod tests {
373    use super::*;
374    use crate::{from_slice, to_slice};
375
376    #[test]
377    fn owned_roundtrip_primitives() {
378        let cases = [
379            Value::Nil,
380            Value::Bool(true),
381            Value::Number(Number::from(7u64)),
382            Value::Number(Number::from(-3i64)),
383            Value::Number(Number::Float(1.25)),
384            Value::String("hi".to_string()),
385            Value::Bin(vec![0x01, 0x02]),
386        ];
387        for v in cases.iter() {
388            let mut buf = [0u8; 32];
389            let len = to_slice(v, &mut buf).unwrap();
390            let decoded = from_slice::<Value>(&buf[..len]).unwrap();
391            assert_eq!(&decoded, v);
392        }
393    }
394
395    #[test]
396    fn owned_nested_roundtrip() {
397        let v = Value::Array(vec![
398            Value::Map(vec![
399                (Value::String("k".into()), Value::Bool(false)),
400                (Value::Number(1u64.into()), Value::String("v".into())),
401            ]),
402            Value::Extension {
403                r#type: 1,
404                data: vec![0x12, 0x34],
405            },
406        ]);
407        let mut buf = [0u8; 128];
408        let len = to_slice(&v, &mut buf).unwrap();
409        let decoded = from_slice::<Value>(&buf[..len]).unwrap();
410        assert_eq!(decoded, v);
411    }
412}
messagepack_serde/value/value_owned.rs

messagepack_serde/value/
value_owned.rs
