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) => {
102                crate::extension::ext_ref::serialize(&ext.as_ref(), serializer)
103            }
104            Value::Number(n) => n.serialize(serializer),
105            Value::String(s) => serializer.serialize_str(s),
106            Value::Array(vs) => vs.serialize(serializer),
107            Value::Map(items) => {
108                let mut map = serializer.serialize_map(Some(items.len()))?;
109                for (k, v) in items.iter() {
110                    map.serialize_entry(k, v)?;
111                }
112                map.end()
113            }
114        }
115    }
116}
117
118impl<'de> serde::Deserialize<'de> for Value {
119    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
120    where
121        D: serde::Deserializer<'de>,
122    {
123        struct ValueVisitor;
124        impl<'de> Visitor<'de> for ValueVisitor {
125            type Value = Value;
126            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
127                f.write_str("expect valid messagepack")
128            }
129
130            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
131            where
132                E: serde::de::Error,
133            {
134                Ok(Value::Bool(v))
135            }
136
137            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
138            where
139                E: serde::de::Error,
140            {
141                Ok(Value::from(v))
142            }
143
144            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
145            where
146                E: serde::de::Error,
147            {
148                Ok(Value::from(v))
149            }
150
151            fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
152            where
153                E: serde::de::Error,
154            {
155                Ok(Value::from(v))
156            }
157            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
158            where
159                E: serde::de::Error,
160            {
161                Ok(Value::from(v))
162            }
163
164            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
165            where
166                E: serde::de::Error,
167            {
168                Ok(Value::from(v))
169            }
170
171            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
172            where
173                E: serde::de::Error,
174            {
175                Ok(Value::from(v))
176            }
177
178            fn visit_none<E>(self) -> Result<Self::Value, E>
179            where
180                E: serde::de::Error,
181            {
182                Ok(Value::Nil)
183            }
184            fn visit_unit<E>(self) -> Result<Self::Value, E>
185            where
186                E: serde::de::Error,
187            {
188                Ok(Value::Nil)
189            }
190
191            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
192            where
193                E: serde::de::Error,
194            {
195                Ok(Value::Bin(v.to_vec()))
196            }
197
198            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
199            where
200                E: serde::de::Error,
201            {
202                Ok(Value::Bin(v))
203            }
204
205            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
206            where
207                D: serde::Deserializer<'de>,
208            {
209                let ext = crate::extension::ext_owned::deserialize(deserializer)?;
210                Ok(Value::Extension(ext))
211            }
212
213            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
214            where
215                A: serde::de::SeqAccess<'de>,
216            {
217                let mut buf = Vec::new();
218                if let Some(size) = seq.size_hint() {
219                    buf.reserve(size);
220                }
221
222                while let Some(v) = seq.next_element::<Value>()? {
223                    buf.push(v);
224                }
225                Ok(Value::Array(buf))
226            }
227
228            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
229            where
230                A: serde::de::MapAccess<'de>,
231            {
232                let mut buf = Vec::new();
233                if let Some(size) = map.size_hint() {
234                    buf.reserve(size);
235                }
236
237                while let Some(v) = map.next_entry::<Value, Value>()? {
238                    buf.push(v);
239                }
240                Ok(Value::Map(buf))
241            }
242        }
243        deserializer.deserialize_any(ValueVisitor)
244    }
245}
246
247impl From<()> for Value {
248    fn from(_: ()) -> Self {
249        Value::Nil
250    }
251}
252
253impl From<bool> for Value {
254    fn from(v: bool) -> Self {
255        Value::Bool(v)
256    }
257}
258
259impl From<u8> for Value {
260    fn from(v: u8) -> Self {
261        Value::Number(Number::from(v))
262    }
263}
264impl From<u16> for Value {
265    fn from(v: u16) -> Self {
266        Value::Number(Number::from(v))
267    }
268}
269impl From<u32> for Value {
270    fn from(v: u32) -> Self {
271        Value::Number(Number::from(v))
272    }
273}
274impl From<u64> for Value {
275    fn from(v: u64) -> Self {
276        Value::Number(Number::from(v))
277    }
278}
279
280impl From<i8> for Value {
281    fn from(v: i8) -> Self {
282        Value::Number(Number::from(v))
283    }
284}
285impl From<i16> for Value {
286    fn from(v: i16) -> Self {
287        Value::Number(Number::from(v))
288    }
289}
290impl From<i32> for Value {
291    fn from(v: i32) -> Self {
292        Value::Number(Number::from(v))
293    }
294}
295impl From<i64> for Value {
296    fn from(v: i64) -> Self {
297        Value::Number(Number::from(v))
298    }
299}
300
301impl From<f32> for Value {
302    fn from(v: f32) -> Self {
303        Value::Number(Number::Float(v.into()))
304    }
305}
306impl From<f64> for Value {
307    fn from(v: f64) -> Self {
308        Value::Number(Number::Float(v))
309    }
310}
311
312impl From<Number> for Value {
313    fn from(v: Number) -> Self {
314        Value::Number(v)
315    }
316}
317
318impl TryFrom<usize> for Value {
319    type Error = core::num::TryFromIntError;
320    fn try_from(value: usize) -> Result<Self, Self::Error> {
321        Number::try_from(value).map(Self::from)
322    }
323}
324
325impl TryFrom<isize> for Value {
326    type Error = core::num::TryFromIntError;
327    fn try_from(value: isize) -> Result<Self, Self::Error> {
328        Number::try_from(value).map(Self::from)
329    }
330}
331
332impl From<&str> for Value {
333    fn from(v: &str) -> Self {
334        Value::String(v.to_string())
335    }
336}
337impl From<String> for Value {
338    fn from(v: String) -> Self {
339        Value::String(v)
340    }
341}
342impl From<&[u8]> for Value {
343    fn from(v: &[u8]) -> Self {
344        Value::Bin(v.to_vec())
345    }
346}
347impl From<Vec<u8>> for Value {
348    fn from(v: Vec<u8>) -> Self {
349        Value::Bin(v)
350    }
351}
352
353impl From<ExtensionOwned> for Value {
354    fn from(v: ExtensionOwned) -> Self {
355        Value::Extension(v)
356    }
357}
358
359impl From<ValueRef<'_>> for Value {
360    fn from(v: ValueRef<'_>) -> Self {
361        match v {
362            ValueRef::Nil => Value::Nil,
363            ValueRef::Bool(b) => Value::Bool(b),
364            ValueRef::Bin(b) => Value::Bin(b.to_vec()),
365            ValueRef::Extension(ext) => Value::Extension(ext.into()),
366            ValueRef::Number(n) => Value::Number(n),
367            ValueRef::String(s) => Value::String(s.to_string()),
368            ValueRef::Array(items) => Value::Array(items.into_iter().map(Value::from).collect()),
369            ValueRef::Map(items) => Value::Map(
370                items
371                    .into_iter()
372                    .map(|(k, v)| (Value::from(k), Value::from(v)))
373                    .collect(),
374            ),
375        }
376    }
377}
378
379#[cfg(test)]
380mod tests {
381    use super::*;
382    use crate::{from_slice, to_slice};
383
384    #[test]
385    fn owned_roundtrip_primitives() {
386        let cases = [
387            Value::Nil,
388            Value::Bool(true),
389            Value::Number(Number::from(7u64)),
390            Value::Number(Number::from(-3i64)),
391            Value::Number(Number::Float(1.25)),
392            Value::String("hi".to_string()),
393            Value::Bin(vec![0x01, 0x02]),
394        ];
395        for v in cases.iter() {
396            let mut buf = [0u8; 32];
397            let len = to_slice(v, &mut buf).unwrap();
398            let decoded = from_slice::<Value>(&buf[..len]).unwrap();
399            assert_eq!(&decoded, v);
400        }
401    }
402
403    #[test]
404    fn owned_nested_roundtrip() {
405        let v = Value::Array(vec![
406            Value::Map(vec![
407                (Value::String("k".into()), Value::Bool(false)),
408                (Value::Number(1u64.into()), Value::String("v".into())),
409            ]),
410            Value::Extension(ExtensionOwned {
411                r#type: 1,
412                data: vec![0x12, 0x34],
413            }),
414        ]);
415        let mut buf = [0u8; 128];
416        let len = to_slice(&v, &mut buf).unwrap();
417        let decoded = from_slice::<Value>(&buf[..len]).unwrap();
418        assert_eq!(decoded, v);
419    }
420}
421
422#[cfg(all(test, feature = "std"))]
423mod reader_tests {
424    use super::*;
425    use crate::from_reader;
426
427    #[test]
428    fn value_owned_from_reader_str_and_bin() {
429        // fixstr "hi"
430        let mut r1 = std::io::Cursor::new([0xa2, 0x68, 0x69]);
431        let v1: Value = from_reader(&mut r1).unwrap();
432        assert_eq!(v1.as_string(), Some("hi"));
433
434        // bin8 [0x01, 0x02, 0x03]
435        let mut r2 = std::io::Cursor::new([0xc4, 0x03, 0x01, 0x02, 0x03]);
436        let v2: Value = from_reader(&mut r2).unwrap();
437        assert_eq!(v2.as_bin(), Some(&[1u8, 2, 3][..]));
438    }
439}
messagepack_serde/value/value_owned.rs

messagepack_serde/value/
value_owned.rs
