Skip to main content

bunsen_tool/support/
value.rs

1use serde::{
2    Serialize,
3    Serializer,
4    ser::{
5        SerializeMap,
6        SerializeSeq,
7    },
8};
9
10/// A document: a tree of strings, lists and maps whose keys keep the order
11/// they were added in.
12#[derive(Clone, Debug, PartialEq)]
13pub enum Value {
14    /// A string.
15    Str(String),
16
17    /// A list.
18    List(Vec<Value>),
19
20    /// A map, in the order its keys were added.
21    Map(Vec<(String, Value)>),
22}
23
24impl Value {
25    /// A map of `entries`, in their order.
26    pub fn map<K: Into<String>>(entries: impl IntoIterator<Item = (K, Value)>) -> Value {
27        Value::Map(entries.into_iter().map(|(k, v)| (k.into(), v)).collect())
28    }
29
30    /// A string.
31    pub fn str(s: impl Into<String>) -> Value {
32        Value::Str(s.into())
33    }
34
35    /// The value under `key`, in a map.
36    pub fn get(
37        &self,
38        key: &str,
39    ) -> Option<&Value> {
40        match self {
41            Value::Map(entries) => entries.iter().find(|(k, _)| k == key).map(|(_, v)| v),
42            _ => None,
43        }
44    }
45}
46
47impl Serialize for Value {
48    fn serialize<S: Serializer>(
49        &self,
50        serializer: S,
51    ) -> Result<S::Ok, S::Error> {
52        match self {
53            Value::Str(s) => serializer.serialize_str(s),
54            Value::List(items) => {
55                let mut seq = serializer.serialize_seq(Some(items.len()))?;
56                for item in items {
57                    seq.serialize_element(item)?;
58                }
59                seq.end()
60            }
61            Value::Map(entries) => {
62                let mut map = serializer.serialize_map(Some(entries.len()))?;
63                for (k, v) in entries {
64                    map.serialize_entry(k, v)?;
65                }
66                map.end()
67            }
68        }
69    }
70}