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

messagepack_serde/value/
value_owned.rs
